js实现常见排序算法

---

前言

排序算法这玩意吧，感觉平时写代码又用的少，然后你不懂又不行，还每次敲完，过一阵子又忘了，就参考了很多大佬的文章记录一下方便以后复习。

---

一、排序相关概念

1.比较排序和非比较排序

我们将排序的时候元素之间是否需要比较分为：比较排序和非比较排序

比较排序

通过元素之间比较之后再决定先后顺序，如下面的冒泡排序，每次都是选取两个元素进行比较。比较排序的时间复杂度通常为 O(n2) 或者 O(nlogn)，时间复杂度不能突破O(nlogn),所以也叫非线性时间比较类排序。

非比较排序

非比较排序就是不需要通过元素之间的比较就可以确定每个元素的位置，如下是基数排序的动图，排序时每个元素并不需要比较，而是有自己固定的位置。它可以突破比较排序的下限O(nlogn)，可以达到 O(n)，但是都需要额外的空间开销，所以也称线性时间非比较类排序。

2.稳定性和不稳定性

稳定： 如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

二、各排序算法对比

三、排序算法中的通用函数以及对数器

实现各算法之前先实现一些简单的通用函数以及实现一个对数器用于检验我们实现的算法是否正确。

1.通用函数

交换函数

// 普通版本（辅助变量temp，适合所有场景，大家最常用的方法，较慢）
function swap(arr,i,j) {
	let temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}
// 位运算版本（位运算一般较快.但特殊情况自己与自己交换会变为0）
function swap2(arr,i,j) {
	arr[i] = arr[i] ^ arr[j];
	arr[j] = arr[i] ^ arr[j];
	arr[i] = arr[i] ^ arr[j];
}
// 加减版本（可能越界）
function swap3(arr,i,j) {
	arr[i] = arr[i] + arr[j];
	arr[j] = arr[i] - arr[j];
	arr[i] = arr[i] - arr[j];
}

取两索引的中间下标，中间值mid

// 普通版 有可能越界
let mid = Math.floor((left + right)/2);
// 优化版
let mid = Math.floor(left + (right - left)/2);
// 位运算版
//>>右移,带符号 >>>右移,无符号 右移一位相当于/2
//注意位移运算外面的小括号,因为位运算优先级低
//位运算相对较快
let mid = Math.floor(left + ((right - left) >> 1));

2.对数器

用原生的方法检验自己写的方法是否正确。先随机产生数组，用自己的方法进行排序，再用原生的方法进行排序，比较两次排序是否结果一样。可以调整随机产生的数组的数据量产生更大的数据验证。

class Comparator {
  constructor() {
    // 用于后续对比各排序算法时排序同样的随机数据
    this.dataStore = [];
  }
  // 生成随机数组
  getRandomArr(size, maxValue) {
    return Array(size).fill(0).map(() => Math.floor(Math.random() * maxValue));
  }
  // 比较两个数组是否相等
  isEqual(arr1, arr2) {
    if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
      return false;
    }

    if (arr1 == null && arr2 == null) {
      return true;
    }

    if (arr1.length != arr2.length) {
      return false;
    }

    for (let i = 0; i < arr1.length; i++) {
      if (arr1[i] != arr2[i]) {
        return false;
      }
    }

    return true;
  }
  // 复制数组
  copyArray(arr) {
    if (arr == null) {
      return null;
    }
    return [...arr];
  }
  // 原生排序
  sort(arr) {
    arr.sort((a, b)=>a - b);
  }
  setData(size) {
    this.dataStore = this.getRandomArr(size,100)
  }
  // 测试我们写的排序 传入我们要检测的排序函数以及随机数据长度
  test(sortFn) {
    // 先获取俩个同样的随机数据的数组
    let arr1 = this.copyArray(this.dataStore)
    let arr2 = this.copyArray(this.dataStore);
    // 先用原生方法对arr1进行排序
    this.sort(arr1);
    // 然后用我们自己写的方法进行排序 并且记录一下消耗时间方便后续对各排序进行对比
    let startTime = new Date().getTime();
    sortFn(arr2);
    let endTime = new Date().getTime();
    let interval = endTime - startTime;
    // 通过isEqual函数验证我们写的排序是否正确
    if (this.isEqual(arr1, arr2)) {
      console.log(`${sortFn.name}排序正确:耗时${interval}毫秒`);
    } else {
      console.log(`${sortFn.name}排序错误`);
    }

  }
}

let comparator = new Comparator; 
comparator.setData(10000);  // 表示生成一个10000组随机数据的数组用于测试
comparator.test(bubbleSort); // bubbleSort排序正确:耗时203毫秒
comparator.test(selectionSort); // selectionSort排序正确:耗时65毫秒
comparator.test(insertSort); // insertSort排序正确:耗时35毫秒
comparator.test(shellSort); // shellSort排序正确:耗时6毫秒

四、各排序算法的实现

有了上面完成的比较器，我们可以很容易检验我们的排序算法是否正确，接下来是各种排序的具体实现

1.冒泡排序

依次比较两个相邻的元素，一层一层的将较大的元素往后移动，其现象和气泡在上升过程中慢慢变大类似，故成为冒泡排序。

算法思想

从第一个和第二个开始比较，如果第一个比第二个大，则交换位置，然后比较第二个和第三个，逐渐往后

经过第一轮后最大的元素已经排在最后，所以重复上述操作的话第二大的则会排在倒数第二的位置。

那重复上述操作n-1次即可完成排序，因为最后一次只有一个元素所以不需要比较

过程图解

代码实现

function bubbleSort(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]) {
        swap(arr, j, j + 1);
      }
    }
  }
}

comparator.test(bubbleSort);

算法分析

稳定性：我们从代码中可以看出只有前一个元素大于后一个元素才可能交换位置，所以相同元素的相对顺序不可能改变，所以它是稳定排序

比较性：因为排序时元素之间需要比较，所以是比较排序

时间复杂度：因为它需要双层循环n*(n-1))，所以平均时间复杂度为O(n^2)

空间复杂度：只需要常数个辅助单元，所以空间复杂度为O(1)，我们把空间复杂度为O(1)的排序成为原地排序（in-place）

2.选择排序

工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，所以称为：选择排序

算法思想

设第一个元素为比较元素，依次和后面的元素比较，比较完所有元素找到最小的元素，将它和第一个元素互换

重复上述操作，我们找出第二小的元素和第二个位置的元素互换，以此类推找出剩余最小元素将它换到前面，即完成排序

过程图解

代码实现

function selectionSort(arr) {
  // 第一层循环是遍历的次数
  for (let i = 0; i < arr.length; i++){
    // 第二层表示每次遍历的元素中都能找到最小的并且放到最前面
    for (let j = i + 1; j < arr.length; j++){
      if (arr[i] > arr[j]) {
        swap(arr, i, j);
      }
    }
  }
}
comparator.test(selectionSort);

算法分析

稳定性：因为存在任意位置的两个元素交换，比如[5, 8, 5, 2]，第一个5会和2交换位置，所以改变了两个5原来的相对顺序，所以为不稳定排序。
比较性：因为排序时元素之间需要比较，所以是比较排序
时间复杂度：选择排序同样是双层循环n*(n-1))，所以时间复杂度也为：O(n^2)
空间复杂度：只需要常数个辅助单元，所以空间复杂度也为O(1)

3.插入排序

工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法思想

第二个元素开始和前面的元素进行比较，如果前面的元素比当前元素大，则将前面元素 后移，当前元素依次往前，直到找到比它小或等于它的元素插入在其后面
然后选择第三个元素，重复上述操作，进行插入
依次选择到最后一个元素，插入后即完成所有排序

过程图解

代码实现

function insertSort(arr) {
  // 第一层循环表示依次从第一个元素开始插入到前面已经维持好的序列中
  for (let i = 1; i < arr.length; i++){
    // 使用临时变量存储当前要插入的值
    let temp = arr[i];
    // 要插入的元素和前面已经排好序的元素依次对比,直到前面的元素比当前要插入的小，或者前面已经没有可以对比的元素了
    let j = i-1;
    for (; j >= 0 && temp < arr[j]; j--){
      arr[j+1] = arr[j];
    }
    arr[j+1] = temp;
  }
  
}
comparator.test(insertSort);

算法分析

稳定性：从代码我们可以看出只有比较元素大于当前元素，比较元素才会往后移动，所以相同元素是不会改变相对顺序。
比较性：因为排序时元素之间需要比较，所以是比较排序
时间复杂度：插入排序同样需要两次循坏一个一个比较，故时间复杂度也为O(n^2)
空间复杂度：只需要常数个辅助单元，所以空间复杂度也为O(1)

4.希尔排序

第一个突破O(n2)的排序算法，是简单插入排序经过改进之后的一个更高效的版本。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

算法思想

先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序

过程图解

代码实现

function shellSort(arr) {
  // 设置增量
  let step = Math.floor(arr.length / 2);
  while (step > 0) {
    // 从增量值开始进行插入排序
    for (let i = step; i < arr.length; i++) {
      let temp = arr[i];
      let j = i - step;
      for (; j >= 0 && arr[j] > temp; j -= step) {
        arr[j + step] = arr[j];
      }
      arr[j + step] = temp;
    }
    // 每次增量缩小一半
    step = Math.floor(step / 2)
  }
}

comparator.test(shellSort);

算法分析

稳定性：因为希尔排序是间隔的插入，所以存在相同元素相对顺序被打乱，所以是不稳定排序
比较性：因为排序时元素之间需要比较，所以是比较排序
时间复杂度：最坏时间复杂度O(n2)平均复杂度为O(n1.3)
空间复杂度：只需要常数个辅助单元，所以空间复杂度也为O(1)

5.归并排序

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

算法思想

把长度为n的输入序列分成两个长度为n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列。

过程图解

代码实现

function mergeSort(arr) {
	merge(arr,0,arr.length-1)
}

// merge其实就是合并两个有序数组，这里我们是对数组arr索引left~mid以及mid+1~right进行合并
function merge(arr,left,right){
	//如果起始位置比终止位置小就开启排序逻辑
	if(left<right){
		//确定中间值，将数组分成两部分
		let mid = Math.floor((left+right)/2)		
		//递归执行左侧部分的分解
		merge(arr,left,mid)
		//递归执行右侧部分的分解
		merge(arr,mid+1,right)
		//分解完毕从最后一层递归中合并
		//定义左部分数组和右部分数组比较的起点
		let [l,r] = [left,mid+1]
		//定义临时数组的指针
		let k = 0
		//当左侧数组和右侧数组任意一个没有走完的时候，因为分解时可能左右数组长度不一样
    	let temp = []
    	// 依次对比两数组的元素，谁小就谁放到前面， 直到一个数组已经走完
		while(l<=mid&&r<=right){
			temp[k++] = arr[l] >= arr[r] ? arr[r++] : arr[l++]
		}
		//当上面循环跳出时代表至少有一个数组走到头了
		//比较左数组是否到达终点，如果没有就继续向临时数组放值
		while(l<=mid){
			temp[k++] = arr[l++]
		}
		//比较右数组是否到达终点如果没有就继续向临时数组放值
		while(r<=right){
			temp[k++] = arr[r++]
		}
		//重制临时数组指针
		k = 0
		//从此次归并的长度范围将临时数组的排序结果放入原数组
		while(left<=right){
			arr[left++] = temp[k++]
		}
	}
}

comparator.test(mergeSort);

算法分析

稳定性：我们从代码中可以看到当左边的元素小于等于右边的元素就把左边的排前面，而原本左边的就是在前面，所以相同元素的相对顺序不变，故为稳定排序
比较性：因为排序时元素之间需要比较，所以是比较排序
时间复杂度：复杂度为O(nlog^n)
空间复杂度：在合并子列时需要申请临时空间，而且空间大小随数列的大小而变化，所以空间复杂度为O(n)

6.快速排序

快速排序使用得最广泛，速度也很快，不然为啥叫快排呢，对吧。

算法思想

在所有数据中，选择一个元素作为基准
所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素，都移到"基准"的右边。
对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

过程图解

代码实现

function quickSort(arr) {
  quick(arr,0,arr.length-1)
}
// 总的来说就是遍历数组，取一个基准值（上面动图取的是最右边的值，这里是取数组最中间的值），大于这个值就放右边，小于放左边
function quick(arr, left, right) {
  if (left >= right) {
    return;
  }
  // 取中间值
  let midVal = arr[Math.floor(left + Math.floor((right - left) / 2))];
  // 通过维持一个左边界和右边界
  let leftSide = left - 1;
  let rightSide = right + 1;
  // 设置当前值指针
  let cur = left;
  // 直到当前值指针>=等于右边界
  while (cur < rightSide) {
    // 当前值<指定值，那么把当前值和左边界的下一个值进行交换 
    // 然后当前值指针继续向右移，左边界也右移
    if (arr[cur] < midVal) {
      swap(arr, leftSide + 1, cur);
      cur++;
      leftSide++;
    } else if (arr[cur] > midVal) {
      // 当前值 > 指定值，那么把当前值和右边界的前面的值进行交换 
      // 然后右边界向左移 当前值指针保持不动
      swap(arr, cur, rightSide - 1);
      rightSide--;
    } else {
      // 当前值=指定值，当前值指针右移
      cur++;
    }
  }
  // 此时左边界以左全部小于指定值 右边界以右全部大于指定值
  // 然后对小于指定值的元素和大于等于指定值的元素分别进行快排
  quick(arr, left, leftSide);
  quick(arr, rightSide, right);
}

comparator.test(quickSort);

算法分析

稳定性：快速排序是不稳定排序，就如我们实现的代码，排序[9,8,8]时，取中间的8为基准值，遍历到9时，与最后的8交换，不满足稳定性的概念。
比较性：因为排序时元素之间需要比较，所以是比较排序
时间复杂度：快速排序的平均时间复杂度和最坏时间复杂度分别是O(nlgn)、O(n^2)。
最好时间复杂度：O(nlogn)。每次选取分区点时，都能选中中位数，把数组等分成两个。
最坏时间复杂度：O(n^2)。每次分区都选中了最小值或最大值，得到不均等的两组。那么就需要 n 次的分区操作，每次分区平均扫描 n / 2 个元素。
空间复杂度：首先就地快速排序使用的空间是O(1)的，也就是个常数级；而真正消耗空间的就是递归调用了，因为每次递归就要保持一些数据；最优的情况下空间复杂度为：O(logn) ；每一次都平分数组的情况；最差的情况下空间复杂度为：O( n )

---

实际速度对比

通过我们前面写的比较器，我们可以对比各排序在各种数据规模下的排序效率

let comparator = new Comparator;
console.log("数据量为100时:")
comparator.setData(100);
comparator.test(bubbleSort);  
comparator.test(selectionSort); 
comparator.test(insertSort); 
comparator.test(shellSort); 
comparator.test(mergeSort); 
comparator.test(quickSort); 
console.log("数据量为1000时:")
comparator.setData(1000);
comparator.test(bubbleSort);  
comparator.test(selectionSort); 
comparator.test(insertSort); 
comparator.test(shellSort); 
comparator.test(mergeSort); 
comparator.test(quickSort); 
console.log("数据量为10000时:")
comparator.setData(10000);
comparator.test(bubbleSort);  
comparator.test(selectionSort); 
comparator.test(insertSort); 
comparator.test(shellSort); 
comparator.test(mergeSort); 
comparator.test(quickSort); 
console.log("数据量为100000时:")
comparator.setData(100000);
comparator.test(bubbleSort);  
comparator.test(selectionSort); 
comparator.test(insertSort); 
comparator.test(shellSort); 
comparator.test(mergeSort); 
comparator.test(quickSort); 
// 下面是控制台打印的结果
// 数据量为100时:
// bubbleSort排序正确:耗时2毫秒
// selectionSort排序正确:耗时1毫秒
// insertSort排序正确:耗时0毫秒
// shellSort排序正确:耗时0毫秒
// mergeSort排序正确:耗时0毫秒
// quickSort排序正确:耗时0毫秒
//  数据量为1000时:
// bubbleSort排序正确:耗时4毫秒
// selectionSort排序正确:耗时2毫秒
// insertSort排序正确:耗时2毫秒
// shellSort排序正确:耗时1毫秒
// mergeSort排序正确:耗时3毫秒
// quickSort排序正确:耗时0毫秒
//  数据量为10000时:
// bubbleSort排序正确:耗时201毫秒
// selectionSort排序正确:耗时64毫秒
// insertSort排序正确:耗时35毫秒
// shellSort排序正确:耗时2毫秒
// mergeSort排序正确:耗时3毫秒
// quickSort排序正确:耗时0毫秒
//  数据量为100000时:
// bubbleSort排序正确:耗时23243毫秒
// selectionSort排序正确:耗时5609毫秒
// insertSort排序正确:耗时3176毫秒
// shellSort排序正确:耗时19毫秒
// mergeSort排序正确:耗时28毫秒
// quickSort排序正确:耗时5毫秒

可以看出随着数据量规模的增大，快排，希尔，归并排序效率要远远高于冒泡，插入，选择。尤其是快排，快到飞起，牛逼。

主要就记录了这最常见的六种排序，后续学习了再更新。还请各位大佬多多指教。

引用

排序算法——（1）简介
排序算法——（2）Python实现十大常用排序算法
图解归并排序过程的JS实现【附源代码】