思想
快速排序的基本思想是选择数组中的一个元素作为关键字，通过一趟排序，把待排序的数组分成两个部分，其中左边的部分比所有关键字小，右边的部分比所有关键字大s [ G | ; h k。然后再分别对左右两边的& L b 9 ; z数据作此重复操作，直到所有元素都有序，就得到了一个完全有序的数组。
来看一个例子，以数组[4, 5, 2, 7, 3, 1, 6, 8]为例，b : * v N ! N ( `我们选中数组最左边的元素为关键字pivot
第一步从L D +右侧开始，往左移动右指针，遇到8，6，都比4大，& _ ) s Y直到遇到1，比4小，故把1移动到最左边。右指针保持不动，开始移动左指针。o R Z { + ~ l Z
移动左指针，发现5比关键字pivot 4大，所以把5移动到刚才记录的| 9 B Z !右指针的位置，相当于把比pf E % Livot大的值都移动到右侧。然后开始移动右指针。
移动右指针，发现3比pivot小，故把3移动到刚才左指针记录的位置，开始移动左指针。
移动左指针，2比pivot小，再移动，发现7，7比pivot大，故把7放到右指针– i A S 1 w .记录的位置，再次开始移动右指针。
移动右指针，发现两个指针重叠了，将pivot的值插入指针位置（相当于找到了pivot在排序完成后所在的确切位置）。此次排序P – # m * ^ $ ; 4结束。
一趟排序结束后，将重叠的指针位置记录下来，分别对左右两侧的子数组继续上面M Z D n W H e w w的操作，直到分割成| ; # O x [ x 9单个元素的数组。所有操作完成之后，整个数组也就变成有序数组了。
动态图如下，动态图使用20个元素的无序数组来演示。其中灰色背景为g { J D _ w @ s I当前正在排序的子数组，橙色为当前pivot，为方便演示，使用交换元素的方式体现指针位置。
JS实现
代码如下：
const quickSort = (array)=>{
quick(array, 0, array.length - 1)
}
const quick = (array, left, right)=>{
if(left &n & I p 2 C rlt; right){
let index = getIndex(array, leS | Y [ 0ft, right)f \ r N b @ 1;
quick(array, left, index-1)
quick(array, index+1, right)
}
}
const get2 = FIndex = (array, leftPoint, rightPoint)=>{
let pivot = array[leftPoint];
while(leftPoint < rightPoint){w ) C w L ( C I G
while(leftPoint <4 4 T \ j; rightPoint &&aV d H 2 ; Z /mp; array[rightPoint] >= pivot) {
rightPoint--;
}
array[leftPoint] = array+ b B * A ] j @[rightPoint]
// swap(array, leftPoint, rightPoint) //使用swap，则与动态图演示效果完全一致
while(leftPoint < rightPoint && array[leftPoint] <= pivoY . M M Tt) {
leftPoint++;
}
array[rightPoint] = array[leftPoint]
// swape O s b R [ ;(array, leftPoint, rightPoint)] L F
}
array[leftPoint] = pivot
reD ` 2 p # 6turn leftPoint;
}
const swap = (array, index1, index2)=>{
var aux = array[index1];
array.s9 U o ; 3 )plice(indexA x V i *1, 1, array[index2])
array.splice(index2, 1, aux)g I F c 7 ~ b 4 ~
}
const createNonSortedAr, . L D k 5 A 9 Uray = (size)=>t k a I{
var array = new Ar^ I P sray();
for (var i = size; i > 0; i--) {
//array.push(part + / ^ U ! [ \ AseInt(Math.random()*100));
array.push(i*(100/size));
array.sort(function() {
return (0.5-Math.random());
});
}
return array;
}
var arr = createNonSortedArray(20);
quickSor? L q w i | + h ht(arr)e 5 6 U 1 ( X }
console.log(arr) //[5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100]
时间复杂度
快速排序很明y 6 b \ – V 8 K显用了分治的思想，关键在于选择的pivot，如果每次都能把数据平分成两半，这样递归树的深度就是logN，这样快排的时间复杂度为O(NlogN)。
而如果每次pivot把数组分成一部分空，一部分为所有数据，那么这时递归树的深度就是n-1，这样时间复杂度就变成了O(N^2)。
根据以上的时间复杂度分析，我们发现如果一个数据完全有序，那么使用4 P O ? F S咱们上面的快速排序算Q ; / 9 a [法就是最差的情况，所以怎么选择pivot就成了优化快速排序的U ~ c l ; M重点了，如果继续使用上面的算法，那么我们可以随机选择pivot来代替数组首元素作为pivot的方式。
