本文介绍了前端常见的五种排序方式。
冒泡排序
冒泡排序得名于其排序方式，它遍历整个数组，将数组的每一项与其后一项进行对比，如果不符合要求就交换位置，一共遍历n轮，n为数组的长度。n轮之后，数组得以完全排序。整个过程符合要求的数组项就像气泡从水底冒到水面一样泡到数组末端，所以叫做冒泡排序。
- 时间复杂度O(n^2)
- 空间复杂度O(1)
- 稳定性：稳定
var arr = [7,8,2,6,10,9,3,1,5,4];
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;
}
bubbleSort(arr); // [1,2,3,4,5,6,7,8,9,10]
选择排序
找到数组中的最小（大）值，并将其放到第一位，然后找到第二小的值放到第二位……以此类推。
- 时间复杂度O(n^2)
- 空间复杂度O(1)
- 稳定性: 不稳定
var arr = [7,8,2,6,10,9,3,1,5,4];
function selectionSort(arr) {
const len = arr.length;
for(let i = 0; i < len; i++) {
let minIndex = i;
for (let j = i + 1; j < len; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
if (minIndex != i) {
[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
}
}
}
return arr;
}
selectionSort(arr); // [1,2,3,4,5,6,7,8,9,10]
插入排序
- 时间复杂度O(n^2)
- 空间复杂度O(1)
- 稳定性：稳定
var arr = [7,8,2,6,10,9,3,1,5,4];
function insertionSort(arr) {
for (let i = 1; i < arr.length; i++) {
const temp = arr[i]; // 从数组第一项开始
let j = i;
while (j > 0 && arr[j - 1] > temp) { // 与当前第i项之前的元素依次比较
arr[j] = arr[j - 1]; // 如果之前的元素比它大，则把之前的元素放到当前元素的位置上
j--; // 继续执行比较，直到j = 0停止
}
arr[j] = temp; // 把当前元素插入到正确的位置
}
return arr;
}
insertionSort(arr); // [1,2,3,4,5,6,7,8,9,10]
归并排序
排序一个数组，我们先把数组从中间分成前后两部分，然后对前后两部分分别排序，再将排好序的两部分合并在一起，这样整个数组就都有序了。归并排序采用的是分治思想。分治，顾名思义，就是分而治之，将一个大问题分解成小的子问题来解决。小的子问题解决了，大问题也就解决了。
- 分的时间复杂度是O(logN)，合的时间复杂度是O(n)，时间复杂度: O(nlogN)
- 空间复杂度：O(n)
- 稳定性：O(n)
var arr = [7,8,2,6,10,9,3,1,5,4];
function mergeSort(arr) {
const rec = (arr) => {
if (arr.length === 1) { return arr; }
const mid = Math.floor(arr.length / 2);
const left = arr.slice(0, mid);
const right = arr.slice(mid, arr.length);
const orderLeft = rec(left);
const orderRight = rec(right);
const res = [];
while(orderLeft.length || orderRight.length) {
if(orderLeft.length && orderRight.length) {
res.push(orderLeft[0] < orderRight[0] ? orderLeft.shift() : orderRight.shift())
} else if(orderLeft.length) {
res.push(orderLeft.shift());
} else if(orderRight.length) {
res.push(orderRight.shift());
}
}
return res;
}
const res = rec(arr);
res.forEach((n, i) => {
arr[i] = n;
});
return arr;
}
mergeSort(arr);
快速排序
- 递归的时间复杂度是O(logN)
- 分区操作的时间复杂度是O(n)
- 时间复杂度：O(nlogN)
- 空间复杂度：O(logn)
- 稳定性：不稳定
var arr = [7,8,2,6,10,9,3,1,5,4];
function quickSort(arr) {
if (arr.length <= 1) { return arr; }
let left = [];
let right = [];
let pivotValue = arr[0];
let len = arr.length;
for(let i = 1; i < len; i++) {
if (arr[i] < pivotValue) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return quickSort(left).concat(pivotValue, quickSort(right));
}
quickSort(arr);
