一、前言
这一部分参考：常用排序算法总结
排序算法大体可分为两种：
一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。
另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。
下表给出了常见比较排序算法的性能：
排序算法稳定性的简单形式化定义为：如果Ai = Aj，排序前Ai在Aj之前，排序后Ai还在Aj之前，则称这种排序算法是稳定的。通俗地讲就是保证排序前后两个相等的数的相对顺序不变。
对于不稳定的排序算法，只要举出一个实例，即可说明它的不稳定性；而对于稳定的排序算法，必须对算法进行分析从而得到稳定的特性。需要注意的是，排序算法是否为稳定的是由具体算法决定的，不稳定的算法在某种条件下可以变为稳定的算法，而稳定的算法在某种条件下也可以变为不稳定的算法。
例如，对于冒泡排序，原本是稳定的排序算法，如果将记录交换的条件改成A[i] >= A[i + 1]，则两个相等的记录就会交换位置，从而变成不稳定的排序算法。
二、排序算法
2.1 冒泡排序
冒泡排序算法的运作如下：
- 比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
let arr = [6, 65, 3, 1, 98, 87, 42, 24];
console.log(arr);
function swap(arr, i, j) {
[arr[i],arr[j]] = [arr[j],arr[i]];
}
//冒泡算法排序
function sortBubble(arr) {
for(let i = 0; i<arr.length;i++){
for(let j = 0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
swap(arr,j,j+1);
}
}
}
}
sortBubble(arr);
console.log(arr);
2.2 鸡尾酒排序
鸡尾酒排序，也叫定向冒泡排序，是冒泡排序的一种改进。此算法与冒泡排序的不同处在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能。
let arr = [6, 65, 3, 1, 98, 87, 42, 24];
console.log(arr);
function swap(arr, i, j) {
[arr[i],arr[j]] = [arr[j],arr[i]];
}
//鸡尾酒排序
function CocktailSort(arr) {
let left = 0;
let right = arr.length-1;
while (left < right){
for(let i = left; i < right;i++){
if(arr[i]>arr[i+1]){
swap(arr,i,i+1);
}
}
right--;
for(let j = right;j>left;j--){
if(arr[j] < arr[j-1]){
swap(arr,j,j-1);
}
}
left++;
}
}
CocktailSort(arr);
console.log(arr);使用鸡尾酒排序为一列数字进行排序的过程如图所示：
2.3 选择排序
选择排序也是一种简单直观的方法，以由小到大排序为例：对于初始序列，假设第一个为最小值（下标min），然后依次比较序列中其他数值，遇到比min更小的数值，交换两者的下标，然后再继续往下比较，直到与序列的其他值都有比较。然后交换最终带有min下标和最初带有min下标的值。这样就完成一轮比较，找到序列中最小的值。
注意选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。
let arr = [6, 65, 3, 1, 98, 87, 42, 24];
console.log(arr);
function swap(arr, i, j) {
[arr[i],arr[j]] = [arr[j],arr[i]];
}
//选择排序
function selectSort(arr) {
let min;
for(let i = 0; i < arr.length-1;i++){
min = i;
for(let j = i+1;j<arr.length;j++){
if(arr[j] < arr[min]){
min = j;
}
}
if(min !== i){
swap(arr,i,min);
}
}
}
selectSort(arr);
console.log(arr);上述代码对序列{ 8, 5, 2, 6, 9, 3, 1, 4, 0, 7 }进行选择排序的实现过程如图：
2.4 插入排序
具体算法描述如下：
- 从第一个元素开始，该元素可以认为已经被排序
- 取出下一个元素，在已经排序的元素序列中从后向前扫描
- 如果该元素（已排序）大于新元素，将该元素移到下一位置
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
- 将新元素插入到该位置后
- 重复步骤2~5
function insertSort(arr) {
for (let i = 1; i < arr.length; i++) {
let get = arr[i];
let j = i - 1;
while (j >= 0 && arr[j] > get) {
//比较之后的动作第一步一定是先移动排好序的数字，然后才是放要插入的get
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = get;//放要插入的get
}
}
insertSort(arr);
console.log(arr);2.5 插入排序的改进：二分插入排序
对于插入排序，如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的次数，我们称为二分插入排序
function InsertionSortDichotomy(arr) {
for (let i = 1; i < arr.length; i++) {
let get = arr[i];
let left = 0;
let right = i - 1;
//二分法
while (left <= right) {
let mid = parseInt((left + right) / 2);
if (arr[mid] > get) {
right = mid - 1;
} else {
left = mid + 1;
}
}
//console.log(left);
//插入排序
for (let j = i - 1; j >= left; j--) {
arr[j + 1] = arr[j];
}
arr[left] = get;
}
}
InsertionSortDichotomy(arr);
console.log(arr);2.5 插入排序的更高效改进：希尔排序(Shell Sort)
希尔排序，也叫递减增量排序，是插入排序的一种更高效的改进版本。希尔排序是不稳定的排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位
希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插入排序较快）。
假设有一个很小的数据在一个已按升序排好序的数组的末端。如果用复杂度为O(n^2)的排序（冒泡排序或直接插入排序），可能会进行n次的比较和交换才能将该数据移至正确位置。而希尔排序会用较大的步长移动数据，所以小数据只需进行少数比较和交换即可到正确位置。
function shellSort(arr) {
let h = 0;
while (h <= arr.length) {
h = h * 3 + 1;//初始化增量(这个增量其实是没有固定的一个算法的)
}
while (h >= 1) {
for (let i = h; i < arr.length; i = i + h) {
let j = i - h;
let get = arr[i];
//console.log(get);
while (j >= 0 && arr[j] > get) {
arr[j + h] = arr[j];
j = j - h;
}
arr[j + h] = get;
}
h = (h - 1) / 3;
}
}
shellSort(arr);
console.log(arr);以23, 10, 4, 1的步长序列进行希尔排序：
2.6 归并排序(递归版本)
归并排序是创建在归并操作上的一种有效的排序算法，效率为O(nlogn)，1945年由冯·诺伊曼首次提出。递归实现的归并排序是算法设计中分治策略(Divide and Conquer)的典型应用，我们将一个大问题分割成小问题分别解决，然后用所有小问题的答案来解决整个大问题。
function mergeSort(arr) {
// 设置终止的条件，
if (arr.length < 2) {
return arr;
}
//设立中间值
let middle = parseInt(arr.length / 2);
//第1个和middle个之间为左子列
let left = arr.slice(0, middle);
//第middle+1到最后为右子列
let right = arr.slice(middle);
if (left === "undefined" && right === "undefined") {
return false;
}
return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
let result = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
//把left的左子树推出一个，然后push进result数组里
result.push(left.shift());
} else {
//把right的右子树推出一个，然后push进result数组里
result.push(right.shift());
}
}
//经过上面一次循环，只能左子列或右子列一个不为空，或者都为空,把剩下的元素都放入新数组的后面
while (left.length) {
result.push(left.shift());
}
while (right.length) {
result.push(right.shift());
}
return result;
}
console.log(mergeSort(arr));上述代码对序列{ 6, 5, 3, 1, 8, 7, 2, 4 }进行归并排序的实例如下
2.7 快速排序
快速排序使用分治策略(Divide and Conquer)来把一个序列分为两个子序列。步骤为：
- 从序列中挑出一个元素，作为"基准"(pivot).
- 把所有比基准值小的元素放在基准前面，所有比基准值大的元素放在基准的后面（相同的数可以到任一边），这个称为分区(partition)操作。
- 对每个分区递归地进行步骤1~2，递归的结束条件是序列的大小是0或1，这时整体已经被排好序了。
let quicksort = function(arr) {
if(arr.length <= 1) return arr;
let pivot = Math.floor((arr.length -1)/2);
let val = arr[pivot], less = [], more = [];
arr.splice(pivot, 1);
arr.forEach((e)=>{
e < val ? less.push(e) : more.push(e);
});
return (quicksort(less)).concat([val],quicksort(more));
};
console.log(quicksort(arr));使用快速排序法对一列数字进行排序的过程：
参考文章：
2312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
