7種排序算法

冒泡排序

自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換。

function BubbleSort(originalArray) {
  // Flag that holds info about whether the swap has occur or not.
  let swapped = false;
  // Clone original array to prevent its modification.
  const array = [...originalArray];

  for (let i = 1; i < array.length; i += 1) {
    swapped = false;

    for (let j = 0; j < array.length - i; j += 1) {

      // Swap elements if they are in wrong order.
      if (array[j + 1] < array[j]) {
        const tmp = array[j + 1];
        array[j + 1] = array[j];
        array[j] = tmp;

        // Register the swap.
        swapped = true;
      }
    }

    // If there were no swaps then array is already sorted and there is
    // no need to proceed.
    if (!swapped) {
      return array;
    }
  }

  return array;
}
複製代碼

選擇排序

在要排序的一組數中，選出最小的一個數與第一個位置的數交換；而後在剩下的數當中再找最小的與第二個位置的數交換，如此循環到倒數第二個數和最後一個數比較爲止。

function selectionSort(originalArray) {
  const array = [...originalArray];

  for (let i = 0; i < array.length; i += 1) {
    let minIndex = i;
    for (let j = i + 1; j < array.length; j += 1 ) {
      if (array[j] < array[minIndex]) {
        minIndex = j;
      }
    }
    // If new minimum element has been found then swap it with current i-th element.
    if (minIndex !== i) {
      const tmp = array[i];
      array[i] = array[minIndex];
      array[minIndex] = tmp;
    }
  }
  return array;
}
複製代碼

插入排序

在要排序的一組數中，假設前面(n-1) [n>=2] 個數已是排好順序的，如今要把第n個數插到前面的有序數中，使得這n個數也是排好順序的。如此反覆循環，直到所有排好順序。

function insertionSort(originalArray) {
  const array = [...originalArray];

  // Go through all array elements...
  for (let i = 0; i < array.length; i += 1) {
    let currentIndex = i;

    // Go and check if previous elements and greater then current one.
    // If this is the case then swap that elements.
    while (
      array[currentIndex - 1] !== undefined
      && (array[currentIndex] < array[currentIndex - 1])
    ) {
      // Swap the elements.
      const tmp = array[currentIndex - 1];
      array[currentIndex - 1] = array[currentIndex];
      array[currentIndex] = tmp;

      // Shift current index left.
      currentIndex -= 1;
    }
  }

  return array;
}
複製代碼

堆排序

堆是具備如下性質的徹底二叉樹：每一個結點的值都大於或等於其左右孩子結點的值，稱爲大頂堆；或者每一個結點的值都小於或等於其左右孩子結點的值，稱爲小頂堆。以下圖：

小頂堆 與 大頂堆

對應的數組爲：[100, 19, 26, 17, 3, 25, 1, 2, 7] 該數組從邏輯上講就是一個堆結構，咱們用簡單的公式來描述一下堆的定義就是： __大頂堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]  __ __小頂堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]  __

堆排序原理的動畫：

// 從新調整爲大頂堆
function heapify(arr, size, index) {
  let largest = index; // 父級節點
  const left = 2 * index + 1;
  const right = 2 * index + 2;
  if (left < size && arr[left] > arr[largest]) {
      largest = left;
  }
  if (right < size && arr[right] > arr[largest]) {
      largest = right;
  }
  if (largest !== index) {
    swap(arr, index, largest);
    heapify(arr, size, largest);
  }
}
function swap(a, i, j) {
  let tmp = a[i];
  a[i] = a[j];
  a[j] = tmp;
}
//這裏的堆排序用的是最大堆
function heapSort(originalArray) {
  const arr = [...originalArray];
  const size = arr.length;
  // 創建大頂堆
  // Math.floor(size / 2 - 1) 爲父級節點index
  for (let i = Math.floor(size / 2 - 1); i >= 0; i--) {
    heapify(arr, size, i);
  }
  for (let i = size - 1; i >= 0; i--) {
    // 將堆頂元素與末尾元素進行交換，使末尾元素最大
    swap(arr, 0, i);
    // 從新調整爲大頂堆,直到整個堆序列有序。
    heapify(arr, i, 0);
  }
  return arr;
}
複製代碼

歸併排序

歸併排序應用遞歸來把數組分解成左右兩半的一個小數組，直到這個小數組被拆分紅的元素個數<=1;而後再將小數組兩兩合併而成有序的大數組。這裏面就是應用到分治策略。

function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  // 將數組拆分兩半
  let midleIndex =  Math.floor(arr.length / 2);
  let leftArray = arr.slice(0, midleIndex);
  let rightArray = arr.slice(midleIndex, arr.length);
  // 遞歸，將左右兩邊的繼續拆，直到每一個數組的length <= 1;
  let leftSortedArray = mergeSort(leftArray);
  let rightSortedArray = mergeSort(rightArray);
  return mergeArrays(leftSortedArray, rightSortedArray);
}

// 對拆分的數組比較後合併
function mergeArrays(leftArray, rightArray) {
  let sortedArray = [];
  while (leftArray.length && rightArray.length) {
    let minNumElement = null;
    // 找左右兩邊數組最小的那個
    if (leftArray[0] <= rightArray[0]) {
      minNumElement = leftArray.shift();
    } else {
      minNumElement = rightArray.shift();
    }
    // push到空數組
    sortedArray.push(minNumElement);
  }
  if (leftArray.length) {
    sortedArray = sortedArray.concat(leftArray);
  }
  if (rightArray.length) {
    sortedArray = sortedArray.concat(rightArray);
  }
  return sortedArray;
}

複製代碼

快速排序

• 在數組中找到一個基準數（pivot）
• 分區，將數組中比基準數大的放到它的右邊，比基準數小的放到它的左邊
• 繼續對左右區間重複第二步，直到各個區間只有一個數，這時候，數組也就有序了。

function quickSort(sourceArray) {
  const arr = [...sourceArray];
  if(arr.length <= 1) {
    return arr;
  }
  // 初始化中間元素左右兩邊數組
  const leftArray = [];
  const rightArray = [];
  // 將第一個元素做爲基準
  const pivotElement = arr.shift();
  const centerArray = [pivotElement];
  // 每一個元素與基準值比較，分別放在左、中、右數組
  while(arr.length > 0) {
    const currentElement = arr.shift();
    if (currentElement === pivotElement) {
      centerArray.push(currentElement);
    } else if (currentElement < pivotElement) {
      leftArray.push(currentElement);
    } else {
      rightArray.push(currentElement);
    }
  }
  // 對左右的數組遞歸排序
  const leftSortedArray = quickSort(leftArray);
  const rightSortedArray = quickSort(rightArray);
  // 最後將排好序的數組合並
  return leftSortedArray.concat(centerArray, rightSortedArray);
}
複製代碼

希爾排序

首先取 gap = Math.floor(arr.length / 2), 將數組分爲 4 組，以下圖中相同顏色表明一組：

而後分別對 4 個小組進行插入排序，排序後的結果爲：

而後，取gap = Math.floor(gap / 2)，將原數組分爲 2 小組，以下圖：

而後分別對 2 個小組進行插入排序，排序後的結果爲：

最後，取 d~3~ = 1，進行插入排序後獲得最終結果：

function shellSort(originArray) {
  const arr = [...originArray];
  // 定義基準間隔
  let gap = Math.floor(arr.length / 2);
  while (gap > 0) {
    // 循環全部間距的元素
    for(let i = 0; i < (arr.length - gap); i += 1) {
      let currentIndex = i;
      let gapShiftedIndex = i + gap;
      console.log(gap);
      while (currentIndex >= 0) {
        // 比較交換數組
        if(arr[gapShiftedIndex] < arr[currentIndex]) {
          let tmp = arr[currentIndex];
          arr[currentIndex] = arr[gapShiftedIndex];
          arr[gapShiftedIndex] = tmp;
        }
        gapShiftedIndex = currentIndex;
        currentIndex -= gap;
      }
    }
    gap = Math.floor(gap / 2);
  }
  return arr;
}
複製代碼

附：7種數組排序算法的複雜度：