排序算法总结（JavaScript版）

一、归并排序

• 归并排序是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法的思想。将已有序的子序列合并，得到完全有序的序列。即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
• 时间复杂度：O(nlogN)
• 代码实现：

function merge(arr, l, m, r) {
    let help = new Array(r - l + 1);
    let p1 = l;
    let p2 = m + 1;
    let i = 0;
    while (p1 <= m && p2 <= r) {
        help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
    }
    while (p1 <= m) {
        help[i++] = arr[p1++];
    }
    while (p2 <= r) {
        help[i++] = arr[p2++];
    }
    for (let i = 0; i < help.length; i++){
        arr[l + i] = help[i]
    }
}
function mergeSort(arr, l, r) {
	if (l === r) {
		return;
	}
	let mid = Math.floor((l + r) / 2);
	mergeSort(arr, l, mid);
	mergeSort(arr, mid + 1, r);
	merge(arr, l, mid, r);
}
function main() {
	let arr = [3, 7, 6, 9, 2, 4, 5, 6];
	mergeSort(arr, 0, 7);
	for (let i in arr) {
		console.log(arr[i]); // 2 3 4 5 6 6 7 9
	}
}
main();

二、冒泡排序

• 冒泡排序是一种比较类排序，主要通过两个for循环实现，第一层for循环表示要执行多少趟，第二层for循环表示一趟要比较多少次。
• 时间复杂度：O(n^2)
• 空间复杂度：O(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]) {
                [arr[j],arr[j + 1]] = [arr[j + 1],arr[j]]
            }
        }
    }
    return arr
}
console.log(bubbleSort([2,4,5,1,2,10]));  // [ 1, 2, 2, 4, 5, 10 ]

三、选择排序

• 选择排序主要是通过当前值与当前值后面序列的最小值进行比较，如果有比当前值小的数，就替换掉当前值，没有的话继续下一次比较。
• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

function selectSort(arr) {
	for (let i = 0; i < arr.length; i++) {
		let minIndex = i;
		for (let j = i + 1; j < arr.length; j++) {
			if (arr[j] < arr[minIndex]) {
				minIndex = j;
			}
		}
		[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
	}
	return arr;
}

console.log(selectSort([3, 4, 5, 6, 1, 23, 10])); // [1,  3,  4, 5 , 6, 10, 23]

四、插入排序

• 插入排序主要是确定当前值要插入到前面有序序列的哪个位置上。
• 最好时间复杂度：O(n)（正序）
• 最坏时间复杂度：O(n^2)（逆序）

function insertSort(arr){
    let len = arr.length
    for(let i = 1; i < len; i++){
        let temp = arr[i]
        let j = i - 1;
        while(j >= 0 && arr[j] > temp){
            arr[j + 1] = arr[j]
            j--
        }
        arr[j + 1] = temp
    }
    return arr;
}
let arr = [5,3,4,2,1]
console.log(insertSort(arr))   // [1,2,3,4,5]

五、快速排序

• 快速排序主要是利用一个基准值，采用递归的方式，不断的分成左（小于基准值）右（大于基准值）两个数组，直到左右两个数组只剩下1个元素时，进行返回。
• 最差时间复杂度：O(n^2)（正序）
• 时间复杂度：O(nlogN)
• 空间复杂度：O(logN)
• 代码实现：

function quickSort(arr){
    if(arr.length <= 1){
        return arr
    }
    let mid = Math.floor(arr.length / 2)
    let pivot = arr.splice(mid,1)[0]
    let left = []
    let right = []
    
    for(let i = 0; i < arr.length; i++){
        if(arr[i] < pivot){
            left.push(arr[i])
        }else{
			right.push(arr[i])
        }
    }
    return quickSort(left).concat([pivot],quickSort(right));
}

六、基数排序

• 基数排序主要是入桶出桶的思想，先定义10个桶（数字0-9），获取最大值，然后通过遍历每个数的位数进行入桶，入完桶之后再依次出桶，直到最大值的位数遍历完成。
• 代码实现：

function radixSort(arr) {
	// 取最大值 最大值的位数就是要循环遍历的次数
	const max = Math.max(...arr);

	// 定义一个桶
	const buckets = Array.from({ length: 10 }, () => []);

	// 定义当前要遍历的位数 个位 十位 百位...
	let m = 1;
	while (m < max) {
		// m < 最大值
		// 下方m要 m*=10 -> 每次遍历增加一位
		// 保证遍历完所有可能的位数

		// 放入桶
		arr.forEach((number) => {
			// digit表示某位数的值
			const digit = ~~((number % (m * 10)) / m);

			// 把该位数的值放到桶buckets中
			// 通过索引确定顺序 类比计数排序
			buckets[digit].push(number);
		});

		// 从桶buckets中取值
		// 完成此步后 就完成了一次位数排序
		let ind = 0;
		buckets.forEach((bucket) => {
			while (bucket.length > 0) {
				// shift从头部取值
				// 保证按照队列先入先出
				arr[ind++] = bucket.shift();
			}
		});

		// 每次最外层while循环后m要乘等10
		// 也就是要判断下一位 比如当前是个位 下次就要判断十位
		m *= 10;
	}
}

const arr = [10, 200, 13, 12, 7, 88, 91, 24];

radixSort(arr);
console.log(arr);  // [ 7, 10, 12,  13, 24, 88, 91, 200]

七、计数排序

• 计数排序主要是给每个桶计数，比较浪费空间。
• 时间复杂度：O(n + k)（k是最大值与最小值得差值）
• 代码实现：

function countSort(arr) {
    let max = Math.max(...arr);
    let min = Math.min(...arr);
    let newArr = new Array(max).fill(0);
    for (let i = 0; i < arr.length; i++){
        newArr[arr[i]]++
    }
    for (let i = min, j = 0; i <= max; i++){
        while (newArr[i] > 0) {
            arr[j++] = i
            newArr[i]--
        }
    }
    return arr
}

console.log(countSort([3,4,5,2,1,3,4,10,23])) // [ 1, 2,  3,  3, 4, 4, 5, 10, 23]

八、堆排序

• 堆排序主要是在自己本身进行交换数据的，是一种比较高效的排序算法。
• 时间复杂度：O(nlogN)
• 空间复杂度：O(1)
• 代码实现：

function main() {
	let arr = [10, 32, 4, 3, 1, 5, 30];
	heapSort(arr);
	console.log(arr); // [1, 3, 4, 5, 10, 30, 32]
}
main()

function swap(arr, i, j) {
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp
}
// 某个数处在index位置，往上继续移动(构建大顶堆)
function heapInsert(arr, index) {
    while (arr[index] > arr[Math.floor((index - 1) / 2)] && index > 0) {
        swap(arr, index, Math.floor((index - 1) / 2))
        index = Math.floor((index - 1) / 2)
	}
}

function heapSort(arr) {
	if (arr.length < 2 || arr === null) {
		return;
    }
    // 构建大顶堆
	for (let i =1; i < arr.length; i++) {
		heapInsert(arr, i);
    }
    
    let heapSize = arr.length  // 获取堆的长度
    // 第一个和最后一个交换
	swap(arr,0,--heapSize)
	while (heapSize > 0) {
        heapify(arr, 0, heapSize);
        swap(arr,0,--heapSize)
        // [arr[0], arr[heapSize]] = [arr[heapSize],arr[0]];
	}
}

// 某数处在index位置，能否往下移动
function heapify(arr, index, heapSize) {
    let leftIndex = index * 2 + 1  // 左孩子下标

    while (leftIndex < heapSize) {  // 下标还有孩子的时候

        // 两个孩子中，谁的值大，把下标给lastest
        let lastest = leftIndex + 1 < heapSize && arr[leftIndex + 1] > arr[leftIndex] ? leftIndex + 1 : leftIndex

        // 父和孩子之间，谁的值大，把下标给lastest
        lastest = arr[index] < arr[lastest] ? lastest : index 
        if (lastest === index) {
            break
        }
        swap(arr,index,lastest)
        // [arr[lastest], arr[index]] = [arr[index], arr[lastest]];

        index = lastest;
        leftIndex = index * 2 + 1;

    }
}