快速排序实现
快排1.0版本
-
选数组最后一个元素为哨兵，将前面的元素（除了最后一个元素的数组）进行左右区间划分，使得前面元素比哨兵小的在左边，比哨兵大的在右边。划分区间算法
-
快排每一轮保证了哨兵元素的位置正确
-
最坏时间复杂度为O(n^2)
function quickSort(arr, left = 0, right = arr.length - 1) {
if (left < right) {
const pivotIndex = partition(arr, left, right);
quickSort(arr, left, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, right);
}
return arr;
}
function partition(arr, left, right) {
const pivot = arr[right];
let i = left;
// 分小于等于和大于区间
for (let j = left; j < right; j++) {
if (arr[j] <= pivot) {
// Swap elements at indices i and j
[arr[i], arr[j]] = [arr[j], arr[i]];
i++;
}
}
// 区分结束后，将小于区间的右边一个位置和最后一个哨兵元素位置互换
// Swap pivot element with the element at index i
[arr[i], arr[right]] = [arr[right], arr[i]];
return i;
}
const arr = [4, 2, 6, 3, 7, 9, 0];
const sortedArray = quickSort(arr);
console.log(sortedArray); // 输出：[0, 2, 3, 4, 6, 7, 9]
快排1.0版本另一种实现
- 通过基准值查找,设定第一个为基准值,则比它小的放在左边数组,否则放在右边数组,下次迭代时,依旧按照此规则,则会一直找到最小的
- 因为每次根据基准值分左右,所以最终基准值就会是最值,没有比最值大或小的,所以递归调用的Quick会返回空[]，因为先执行小的递归,再执行大的递归,递归进入回滚,将每次分组的最小基准值依次连接起来,最后形成从小到大的排序实现
时间复杂度
- 在最佳情况下，每一次都平分整个数组。假设数组有 n 个元素，其递归的深度就为 log2n + 1，时间复杂度为：o(nlog2n)。2为底数
- 最坏情况下，假设数组已经排好序，且为所要排序的逆序，每次选择基准元素时总是选择第一个元素或者最后一个元素，那么每次都会有一个子集是空的，递归的层数将达到 n，最后导致算法的时间复杂度退化为 O(n²)。
(() => {
function Quick(list) {
if (list.length == 0) {
return [];
}
let pivot = list[0];
let lesser = [];
let greater = [];
for (let i = 1; i < list.length; i++){ //快排:安装基准值排序,小于基准值放在左边,大于放在右边
if (list[i] < pivot) {
lesser.push(list[i]);
} else {
greater.push(list[i]);
}
}
return Quick(lesser).concat(pivot,Quick(greater));
}
let res=Quick([44,75,23,43,55,12,64,77])
console.log(res);
})()
快排2.0版本
- 利用最上面链接的荷兰国旗问题，每次取数组的最后一个元素为哨兵元素，将哨兵元素前面的区间按照小于哨兵元素、等于哨兵元素、大于哨兵元素划分，然后将哨兵元素和大于区间的第一个元素做交换，这样每次处理了一批等于哨兵元素的位置，然后将小于区间、大于区间按照开始逻辑进行递归
- 也可以不交换，每次直接取最后一个元素为基准，排序整个数组，然后将小于区间、大于区间按照开始逻辑进行递归
- 最坏时间复杂度为O(n^2)
let arr = [3, 5, 6, 7, 8, 3, 4, 5];
//划分小于、等于、大于区间
function cutting(arr, num, pleft, pright) {
let left = pleft - 1;
let right = pright + 1;
for (let i = pleft; i < pright + 1; i++) {
if (i == right) {
break;
}
if (arr[i] < num) {
[arr[left + 1], arr[i]] = [arr[i], arr[left + 1]];
left++;
} else if (arr[i] == num) {
continue;
} else {
[arr[i], arr[right - 1]] = [arr[right - 1], arr[i]];
right--;
//使得下轮比较从右边交换过来的数
i--;
}
}
//返回小于、大于区间的右、左边界
return [left, right];
}
function sort(arr, left, right) {
if (left >= right) {
return;
}
let mid = cutting(arr, arr[right], left, right);
sort(arr, left, mid[0]);
sort(arr, mid[1], right);
}
sort(arr, 0, arr.length - 1);
console.log(arr);
快排3.0版本
- 因为如果数组是逆序，每次取最后一个进行排序，会产生最坏情况O(N^2)
- 从数组中任意取一个数，和最后一个元素进行交换后，在进行上面的排序
- 因为是任意取一个数，所以划分的区间可能是1/3和2/3，也可能是1/2和1/2，把每一种情况求概率累加再求长期期望，得到的结果是O(N*logN)和每次根据数组中点递归，通过Master公式求得的时间复杂度一致
let arr = [3, 5, 6, 7, 8, 3, 4, 5];
//划分小于、等于、大于区间
function cutting(arr, num, pleft, pright) {
let left = pleft - 1;
let right = pright + 1;
for (let i = pleft; i < pright + 1; i++) {
if (i == right) {
break;
}
if (arr[i] < num) {
[arr[left + 1], arr[i]] = [arr[i], arr[left + 1]];
left++;
} else if (arr[i] == num) {
continue;
} else {
[arr[i], arr[right - 1]] = [arr[right - 1], arr[i]];
right--;
//使得下轮比较从右边交换过来的数
i--;
}
}
//返回小于、大于区间的右、左边界
return [left, right];
}
function sort(arr, left, right) {
if (left >= right) {
return;
}
//取区间随机值和最后一个数交换
let rand = left + parseInt(Math.random() * (right - left + 1));
[arr[right], arr[rand]] = [arr[rand], arr[right]];
let mid = cutting(arr, arr[right], left, right);
sort(arr, left, mid[0]);
sort(arr, mid[1], right);
}
sort(arr, 0, arr.length - 1);
console.log(arr);