JavaScript常见排序算法

准备工作

常见排序算法有 ：①选择排序； ②冒泡排序； ③插入排序； ④快速排序；
⑤归并排序； ⑥计数排序； ⑦希尔排序； ⑧堆排序；（粗体字为不稳定排序）

在开始排序算法之前，我们先创建一个待排序和搜索的数组

let arr = [
  10,
  22,
  10,
  1,
  2,
  5,
  3,
  89,
  3,
  7777,
  1111,
  2222,
  0,
  88884,
  222,
  111,
  55,
  44,
  33,
  22,
  11
];

何为冒泡排序（算法复杂度O（n²）,稳定）

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

冒泡排序实现

let bubbleSort = function(arr) {
  for (let i = 0; i < arr.length; i++) {//总的遍历次数
    for (let j = 0; j < arr.length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; //es6解构赋值
      }
    }
  }
  console.log(arr);
  return arr;
};
bubbleSort(arr);

何为选择排序

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

选择排序实现（算法复杂度O（n²）,不稳定）

function selectionSort(arr) {
  let length = arr.length;
  for (let i = 0; i < length - 1; i++) {
    let min_index = i; //假设该项为最小值
    for (let j = i + 1; j < length; j++) {
      if (arr[j] < arr[min_index]) {
        //如果找到比i更小的就改变min_index
        min_index = j;
      }
    }
    [arr[i], arr[min_index]] = [arr[min_index], arr[i]];
  }
  console.log(arr);
  return arr;
}
selectionSort(arr);

何为插入排序（算法复杂度 最好：O(n)最坏:O(n²),稳定）

有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。
插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

插入排序实现

function insertionSort(arr) {
  let length = arr.length;
  let j, temp;
  for (let i = 0; i < length; i++) {
    j = i;
    temp = arr[j]; //待插入的项
    while (j > 0 && arr[j - 1] > temp) {
      //如果已排序的数组中存在比待插项大的，则交换
      arr[j] = arr[j - 1];
      j--;
    }
    arr[j] = temp;
  }
  console.log(arr);
}

何为归并算法（算法复杂度O(nlogn),稳定）

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并算法实现

//治
function merge(left, right) {
  //传进来的left，right都已排好序
  let result = []; //归并后的结果
  let j = 0,
    i = 0; //left和right的指针
  while (i < left.length && j < right.length) {
    if (left[i] < right[j]) {
      //如果当前俩指针left[i]较小则push到result
      result.push(left[i]);
      i++;
    } else {
      result.push(right[j]);
      j++;
    }
  }
  if (i < left.length) {
    //如果j指针先到头
    result = result.concat(left.slice(i, left.length));
  }
  if (j < right.length) { //如果i指针先到头
    result = result.concat(right.slice(j, left.length));
  }
  console.log(result);
  return result;
}

function mergeSort(arr) {
 //分
  let length = arr.length;
  let middle = Math.floor(length / 2);
  let left = arr.slice(0, middle);
  let right = arr.slice(middle, length);
  if (length === 1) {
    //递归结束条件
    return arr;
  }
  return merge(mergeSort(left), mergeSort(right));
}
mergeSort(arr);

何为快速排序（算法复杂度O(nlogn),不稳定）

快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

快速排序实现

//分的同时治
function partition(arr, left, right) {
  let pivot = arr[Math.floor((left + right) / 2)]; //选择基准值
  let i = left,
    j = right; //左右指针
  while (i <= j) {
    //将i指针移动到arr[i]>=pivot的位置
    while (arr[i] < pivot) {
      i++;
    }
    //将j指针移动到arr[j]<=pivot的位置
    while (arr[j] > pivot) {
      j--;
    }
    if (i <= j) {
      //交换arr[i],arr[j]
      [arr[i], arr[j]] = [arr[j], arr[i]];
      j--;
      i++;
    }
  }
  return i; //返回左指针
}
function quick(arr, left, right) {
  let index;
  if (arr.length > 1) {
    index = partition(arr, left, right); //分且治
    //如果index左边的length>2,递归调用
    if (left < index - 1) {
      quick(arr, left, index - 1);
    }
    //如果index右边的length>2,递归调用
    if (right>index) {
      quick(arr, index, right);
    }
  }
}
quick(arr, 0, arr.length - 1);
console.log(arr);