js常用的数组排序算法

选择排序（Selection Sort）

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

实现

function selectionSort(arr) {
    var len = arr.length;
    var minIndex;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) { // 寻找最小的数
                minIndex = j; // 将最小数的索引保存
            }
        }
        [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]
    }
    return arr;
}
const arr = [3, 5, 2, 1, 4, 6, 7, 8, 9]
const result = selectionSort(arr);
console.log(result)

冒泡排序（Bubble Sort）

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

实现

function bubbleSort(arr) {
    const len = arr.length;
    for (let i = 0; i < len - 1; i++) {
      for (let j = 0; j < len - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {// 相邻元素两两对比
          [arr[j],arr[j + 1]] = [arr[j + 1],arr[j]]// 元素交换
        }
      }
    }
    return arr;
  }
const arr = [3, 5, 2, 1, 4, 6, 7, 8, 9]
const result = bubbleSort(arr);
console.log(result)

插入排序（Insertion Sort）

插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

实现

function insertionSort(arr) {
    let len = arr.length;
    let preIndex, current;
    for (let i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while (preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
    return arr;
}
const arr = [3, 5, 2, 1, 4, 6, 7, 8, 9]
const result = insertionSort(arr);
console.log(result)

希尔排序（Shell Sort）

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。

实现

function shellSort(arr) {
    let len = arr.length;
    // gap 即为增量
    for (let gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
        for (let i = gap; i < len; i++) {
            let j = i;
            let current = arr[i];
            while (j - gap >= 0 && current < arr[j - gap]) {
                arr[j] = arr[j - gap];
                j = j - gap;
            }
            arr[j] = current;
        }
    }
    return arr
}
const arr = [3, 5, 2, 1, 4, 6, 7, 8, 9]
const result = shellSort(arr);
console.log(result)

快速排序（Quick Sort）

快速排序（Quicksort）是对冒泡排序算法的一种改进。

实现1

var quickSort = function(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  var pivot = arr[0];
  var left = [];
  var right = [];

  for (var i =1 ; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return [...quickSort(left),pivot,...quickSort(right)];
};
const arr = [3, 5, 2, 1, 4, 6, 7, 8, 9]
const result = quickSort(arr);
console.log(result)

实现2

let quickSort = function (arr, left, right) {
    const partition = function (arr, left, right) {
        var privet = left,
            index = privet + 1;
        for (var i = index; i <= right; i++) {
            if (arr[i] < arr[privet]) {
                [arr[i], arr[index]] = [arr[index], arr[i]];
                index++;
            }
        }
        [arr[privet], arr[index - 1]] = [arr[index - 1], arr[privet]];
        return index - 1;
    };
    if (left < right) {
        partitionIndex = partition(arr, left, right);
        quickSort(arr, left, partitionIndex - 1);
        quickSort(arr, partitionIndex + 1, right);
    }
    return arr;
};
const arr = [3, 5, 2, 1, 4, 6, 7, 8, 9]
const result = quickSort(arr,0,arr.length);
console.log(result)

实现3

let quickSort = function (arr) {
    const sort = function (arr, left, right) {
        if (left > right) return
        let i = left,
            j = right
        const privet = arr[i]
        while (i < j) {
            while (i < j && arr[j] >= privet) {
                j--
            }
            arr[i] = arr[j]
            while (i < j && arr[j] <= privet) {
                i++
            }
            arr[j] = arr[i]
        }
        arr[i] = privet
        sort(arr, left, i - 1)
        sort(arr, i + 1, right)
    }

    sort(arr, 0, arr.length - 1)
    return arr
};
const arr = [3, 5, 2, 1, 4, 6, 7, 8, 9]
const result = quickSort(arr)
console.log(result)