快速排序的JavaScript实现
思想
分治的思想，将原始数组分为较小的数组（但没有像归并排序一样将它们分隔开）。
- 主元选择： 从数组中任意选择一项作为主元，通常为数组的第一项，即arr[i]；或数组的中间项， arr[Math.floor((i+j)/2)];
- 划分操作： 创建两个指针，左边一个指向数组的第一项，右边一个指向数组的最后一项。向右移动左指针，直到找到一个不小于比主元的项；向左移动右指针，直到找到一个不大于主元的项。交换它们。然后重复这个过程，直到左指针超过了右指针。这样使得比主元小的值都排在主元之前，而比主元大的值都排在主元之后。注意：在这个过程中，主元的位置也可能发生了改变；而主元本身在一次划分操作之后不会在正确的位置，其正确的位置应该在本次划分操作后最终得到的那个分割点上（即sliceIndex上），在下轮操作的右半路操作会立刻把主元换到正确的位置上
- 对子数组重复划分操作： 比主元小的项（即主元左边的部分）组成一个子数组，比主元大的项（即主元右边的部分）组成另一个子数组。对这两个小数组继续执行主元选择和划分操作。直到数组已完全排序。
代码
代码段1：
function quickSort(arr) {
return quick(arr, 0, arr.length-1);
}
function quick(arr, left, right) {
if(arr.length>1) {
const sliceIndex = partition(arr, left, right);
if (left < sliceIndex-1) {
quick(arr, left, sliceIndex-1);
}
if (sliceIndex < right) { //*1
quick(arr, sliceIndex, right);//*2
}
}
}
function partition(arr, left, right) {
let i = left;
let j = right;
//const pivot = arr[Math.floor((i+j)/2)];
const pivot = arr[i];
while(i< j) {
while (arr[i] < pivot) { // *3
//Q:*3,*4：为什么这里必须用<和>, 而不能用 <=或>= ?
//A:*3和*4必须是<和>，都不能包含=的情况——实际验证结果也是如此
//因为如果包含=,那么就永远不处理pivot及值等于pivot的情况
i++;
}
while (arr[j] > pivot) { // *4
j--;
}
if(i<j) { // *5
//思考：为什么这里必须是 <= 而不能用 < ?
//A:它其实是为了下面一段的i++,j--。如果分开两段写，那么这里应该是i<j,而下面一段应该是i<=j
const temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
if(i<=j) {//*6
//这里条件一定要是i<=j。
//如果条件仅仅是i<j，那么当i==j的时候就永远也进入不了这个条件，return 的值就是i也是j。那么这一整段partion代码下来，i可能从来没有变过，又原封不动地return了i,即 const sliceIndex = partition(arr, left, right);的这个sliceIndex是和参数left相等的，那么在接下来的quick(arr, sliceIndex, right)就等于之前的quick(arr,left,right)，无限循环了。。。
//总之，这个条件的目的就是让i一定要改变一次
i++;
j--;
}
}
return i;
}
思考
1. 其实每次划分操作之后，主元并不在正确的位置上……那么为什么说每次划分操作都把比主元小的值排在了主元之前，而把比主元大的值都排在了主元之后？
主元本身在一次划分操作之后确实不在正确的位置，其正确的位置应该在本次划分操作后最终得到的那个分割点上（即sliceIndex上），在下轮操作的右半路操作会立刻把主元换到正确的位置上。所以其实在本轮划分操作最后，可以把主元交换到正确的位置上，再进行下轮操作，然后下轮操作就可以不管sliceIndex那个位置上了。
这种写法其实是把小于主元的放到左边，大于主元的放到右边，等于主元的可能在左可能在右，而并不是把主元放在了正确的位置。
代码改进成如下这样就好理解了。
代码段2：
function quickSort(arr) {
return quick(arr, 0, arr.length-1);
}
function quick(arr, left, right) {
if (arr.length ===1) {
return;
}
const sliceIndex = partition(arr, left, right);
if(left < sliceIndex-1) {
quick(arr, left, sliceIndex-1);
}
//下次划分不用再考虑主元了
if(sliceIndex + 1 < right) { //*1
quick(arr, sliceIndex + 1, right);//*2
}
}
function partition(arr, left, right) {
let i = left;
let j = right;
const pivot = arr[i];
while(i < j) {
while(arr[i] < pivot) { //*3
i++;
}
while(arr[j] > pivot) {
j--;
}
if(i < j) {
const temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
if(i <= j) {
i++;
j--;
}
}
//交换主元到划分位置上
const tempPivotIndex = arr.indexOf(pivot); //*7
arr[tempPivotIndex] = arr[i];//*8
arr[i]=pivot;//*9
return i;//其实也是等于j的
}
比起原代码，这种写法:把1,2做了修改，下次划分操作不再考虑本次的slickIndex(即主元已经排好了)；然后新增7,8,*9,就是在本次的划分操作最后，把主元交换到了正确的位置上，这样写，与Es6写法（代码段3）的思路是一致的
工作过程
待画图
性能分析
- 时间复杂度： 最好、平均O(nlogn)，最坏O(n^2)
- 空间复杂度: O(logn), 不稳定
- 特点：越有性能却差
延伸：es6的实现
代码段3：
function quickSortEs6(arr) {
if (!arr.length) {
//要处理的临界条件一定是arr为空的情况，因为可能filter过滤后就一项也不剩了
//arr长度为1的条件可以不单独处理，因为长度为1那么[pivot, ...rest]=arr的rest就为[]了
return [];
}
const [pivot, ...rest] = arr;
return [
...quickSortEs6(rest.filter(item => item < pivot)),
pivot,
...quickSortEs6(rest.filter(item => item >= pivot)) //一定要有=不然和pivot相等的其他值会被过滤掉
]
}
这个比起之前的排法更好理解。
参考资料
-《学习JavaScript数据结构和算法》10.1.5
-《数据结构(C语言版)》9.3.2
