常见排序算法

排序算法比较

排序算法	最坏	最优	平均	空间	稳定性	内部 ( exttt{or}) 外部排序
冒泡排序	(O(n^2))	(O(n))	(O(n^2))	(O(1))	是	In
直接插入排序	(O(n^2))	(O(n))	(O(n^2))	(O(1))	是	In
选择排序	(O(n^2))	(O(n^2))	(O(n^2))	(O(1))	(/)	In
归并排序	(O(nlog n))	(O(nlog n))	(O(nlog n))	(O(n))	是	Out
快速排序	(O(n^2))	(O(nlog n))	(O(nlog n))	(O(nlog n))	(/)	In
希尔排序	(O(n^2))	(O(nlog_2 n))	(O(n^{1.3}))	(O(1))	(/)	In
堆排序	(O(nlog n))	(O(nlog n))	(O(nlog n))	(O(1))	(/)	In
桶排序	(O(n^2))	(O(n + k))	(O(n+k))	(O(n+k))	是	Out
计数排序	(O(n + k))	(O(n + k))	(O(n + k))	(O(k))	是	Out
基数排序	(O(n imes k))	(O(n imes k))	(O(n imes k))	(O(n+k))	是	Out

各种排序算法注意点与实现：

冒泡排序

当数据已经正序时，最优；反序时最坏。

插入排序

直接插入排序

折半插入排序

将向前找的操作改为二分

直接选择排序

归并排序

这是因为归并排序的合并函数，在合并两个有序数组为一个有序数组时，需要借助额外的存储空间。临时内存空间最大不会超过 (n) 个数据的大小，所以空间复杂度是 (O(n)) 。

快速排序

方法一：

const quickSort1 = arr => {
	if (arr.length <= 1) {
		return arr;
	}
	//取基准点
	const midIndex = Math.floor(arr.length / 2);
	//取基准点的值，splice(index,1) 则返回的是含有被删除的元素的数组。
	const valArr = arr.splice(midIndex, 1);
	const midIndexVal = valArr[0];
	const left = []; //存放比基准点小的数组
	const right = []; //存放比基准点大的数组
	//遍历数组，进行判断分配
	for (let i = 0; i < arr.length; i++) {
		if (arr[i] < midIndexVal) {
			left.push(arr[i]); //比基准点小的放在左边数组
		} else {
			right.push(arr[i]); //比基准点大的放在右边数组
		}
	}
	//递归执行以上操作，对左右两个数组进行操作，直到数组长度为 <= 1
	return quickSort1(left).concat(midIndexVal, quickSort1(right));
};
const array2 = [5, 4, 3, 2, 1];
console.log('quickSort1 ', quickSort1(array2));
// quickSort1: [1, 2, 3, 4, 5]

方法二：

// 快速排序
const quickSort = (arr, left, right) => {
	let len = arr.length,
		partitionIndex;
	left = typeof left != 'number' ? 0 : left;
	right = typeof right != 'number' ? len - 1 : right;

	if (left < right) {
		partitionIndex = partition(arr, left, right);
		quickSort(arr, left, partitionIndex - 1);
		quickSort(arr, partitionIndex + 1, right);
	}
	return arr;
};

const partition = (arr, left, right) => {
	//分区操作
	let pivot = left, //设定基准值（pivot）
		index = pivot + 1;
	for (let i = index; i <= right; i++) {
		if (arr[i] < arr[pivot]) {
			swap(arr, i, index);
			index++;
		}
	}
	swap(arr, pivot, index - 1);
	return index - 1;
};

const swap = (arr, i, j) => {
	let temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
};