數(shù)據(jù)結(jié)構(gòu)與算法（排序） --javascript語(yǔ)言描述

Dongjie_Liu 發(fā)布于2019-08-26 11:44 / 2083人閱讀

摘要：最差情況輸入數(shù)組按降序排列。平均情況穩(wěn)定性穩(wěn)定希爾排序排序法是對(duì)相鄰指定距離稱為增量的元素進(jìn)行比較，并不斷把增量縮小至，完成排序。若將兩個(gè)有序表合并成一個(gè)有序表，稱為二路歸并。

冒泡排序

從數(shù)組中第一個(gè)數(shù)開(kāi)始，依次遍歷數(shù)組中的每一個(gè)數(shù)，通過(guò)相鄰比較交換，每一輪循環(huán)下來(lái)找出剩余未排序數(shù)的中的最大數(shù)并”冒泡”至數(shù)列的頂端。

function bubbleSort(arr) {
  for (var i = 0; i < arr.length - 1 ; i++) {
    for (var j = 0; j < arr.length - i - 1 ; j++) {
      if (arr[j] > arr[j+1]) {        //相鄰元素兩兩對(duì)比
          let temp = arr[j+1];        //元素交換
          arr[j+1] = arr[j];
          arr[j] = temp;
      }
    }
  }
  return arr;
}
console.log(bubbleSort([72,54,58,30,31,78,2,77,82,72]))

最佳情況：輸入數(shù)組按升序排列。 T(n) = O(n)
最差情況：輸入數(shù)組按降序排列。 T(n) = O(n2)
平均情況：T(n) = O(n2)
穩(wěn)定性：穩(wěn)定

選擇排序

從所有記錄中選出最小的一個(gè)數(shù)據(jù)元素與第一個(gè)位置的記錄交換；然后在剩下的記錄當(dāng)中再找最小的與第二個(gè)位置的記錄交換，循環(huán)到只剩下最后一個(gè)數(shù)據(jù)元素為止。

function selectionSort(arr) {
  let minIndex,temp;
  for (let i = 0; i < arr.length-1; i++) {
    minIndex = i;
    for (let j = i+1; j < arr.length; j++) {
      if(arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    temp = arr[i];
    arr[i]=arr[minIndex];
    arr[minIndex]=temp;
  }
  return arr;
}

console.log(selectionSort([72,54,58,30,31,78,2,77,82,72]))

最佳情況：T(n) = O(n2)
最差情況：T(n) = O(n2)
平均情況：T(n) = O(n2)
穩(wěn)定性：不穩(wěn)定

插入排序

從待排序的n個(gè)記錄中的第二個(gè)記錄開(kāi)始，依次與前面的記錄比較并尋找插入的位置，每次外循環(huán)結(jié)束后，將當(dāng)前的數(shù)插入到合適的位置。

function insertionSort(arr) {
  for (let i = 1; i < arr.length; i++) {
    let key = arr[i];
    let j = i - 1;
    while (j>=0 && arr[j] > key) {
      arr[j+1] = arr[j];
      j--;
    }
    arr[j+1] = key;
  }
  return arr;
}

console.log(insertionSort([6,10,0,6,5,8,7,4,2,7]))

最佳情況：輸入數(shù)組按升序排列。T(n) = O(n)
最壞情況：輸入數(shù)組按降序排列。T(n) = O(n2)
平均情況：T(n) = O(n2)
穩(wěn)定性：穩(wěn)定

希爾排序

Shell排序法是對(duì)相鄰指定距離(稱為增量)的元素進(jìn)行比較，并不斷把增量縮小至1，完成排序。

function shellSort(arr) {
　　var len = arr.length,
　　temp,
　　gap = 1;
　　while(gap < len/5) { //動(dòng)態(tài)定義間隔序列
　　　　gap =gap*5+1;
　　}
　　for (gap; gap > 0; gap = Math.floor(gap/5)) {
　　　　for (var i = gap; i < len; i++) {
　　　　　　temp = arr[i];
　　　　　　for (var j = i-gap; j >= 0 && arr[j] > temp; j-=gap) {
　　　　　　　　arr[j+gap] = arr[j];
　　　　　　}
　　　　　　arr[j+gap] = temp;
　　　　}
　　}
　　return arr;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(shellSort(arr));

最佳情況：T(n) = O(nlog2 n)
最壞情況：T(n) = O(nlog2 n)
平均情況：T(n) =O(nlog n)
穩(wěn)定性：不穩(wěn)定

歸并排序

歸并排序是分治法（Divide and Conquer）的一個(gè)典型的應(yīng)用。將已有序的子序列合并，得到完全有序的序列；即先使每個(gè)子序列有序，再使子序列段間有序。若將兩個(gè)有序表合并成一個(gè)有序表，稱為二路歸并。

function mergeSort(arr) {
  if(arr.length < 2) {
    return arr;
  }
  let middle = Math.floor(arr.length/2);
  let left = arr.slice(0,middle);
  let right = arr.slice(middle);
  return merge(mergeSort(left),mergeSort(right));
}

function  merge(left,right) {
  let res = [];
  while(left.length && right.length) {
    if(left[0] <= right[0]) {
      res.push(left.shift());
    }
    else {
      res.push(right.shift());
    }
  }
  while(left.length) {
    res.push(left.shift());
  }
  while(right.length) {
    res.push(right.shift());
  }
  return res;
}

let arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(mergeSort(arr));

最佳情況：T(n) = O(n)
最差情況：T(n) = O(nlogn)
平均情況：T(n) = O(nlogn)
穩(wěn)定性：穩(wěn)定

快速排序

1.從待排序的n個(gè)記錄中任意選取一個(gè)記錄（通常選取第一個(gè)記錄）為分區(qū)標(biāo)準(zhǔn);
2.把所有小于該排序列的記錄移動(dòng)到左邊，把所有大于該排序碼的記錄移動(dòng)到右邊，中間放所選記錄，稱之為第一趟排序；
3.然后對(duì)前后兩個(gè)子序列分別重復(fù)上述過(guò)程，直到所有記錄都排好序。

方法一：

function quickSort(arr,left,right) {
  let i = left;
  let j = right;
  let temp = 0;
  if(i < j) {  //待排序的元素至少有兩個(gè)的情況
    temp = arr[i];  //待排序的第一個(gè)元素作為基準(zhǔn)元素
    while(i != j) {    //從左右兩邊交替掃描，直到i = j
      while(j > i && arr[j] >= temp) {
        j --;  //從右往左掃描，找到第一個(gè)比基準(zhǔn)元素小的元素
      }
      arr[i] = arr[j];  //找到這種元素arr[j]后與arr[i]交換
      while(i < j && arr[i] <= temp) {
        i ++;  //從左往右掃描，找到第一個(gè)比基準(zhǔn)元素大的元素
      }
      arr[j] = arr[i];  //找到這種元素arr[i]后，與arr[j]交換
    }
    arr[i] = temp;  //基準(zhǔn)元素歸位
    quickSort(arr,left,i-1);  //對(duì)基準(zhǔn)元素左邊的元素進(jìn)行遞歸排序
    quickSort(arr,i+1,right);  //對(duì)基準(zhǔn)元素右邊的進(jìn)行遞歸排序
  }
  return arr;
}

let arr = [5,7,1,8,4]
console.log(quickSort(arr,0,arr.length-1));

方法二：

function quickSort(arr) {
  if(arr.length <= 1) {
    return arr;
  }
  let middleIndex = Math.floor(arr.length/2);
  let middle = arr.splice(middleIndex,1)[0];//選取基準(zhǔn)值 并從數(shù)組中刪除
  let left = [];  //小于middle的數(shù)組
  let right = [];  //大于middle的數(shù)組
  for (var i = 0; i < arr.length; i++) {
    if(arr[i] < middle) {
      left.push(arr[i]);
    }
    else {
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat([middle],quickSort(right));
}
let arr = [5,7,1,8,4]
console.log(quickSort(arr));

最佳情況：T(n) = O(nlogn)
最差情況：T(n) = O(n2)
平均情況：T(n) = O(nlogn)
穩(wěn)定性：不穩(wěn)定