快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列
基本步骤
三数取中
在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。
1024555-20170108124741566-1283178705.png
根据枢纽值进行分割
1024555-20170108162758159-793891242.png
1024555-20170108162855675-777137351.png
代码实现
OC:
// 交换数组元素
- (void)swap:(NSMutableArray *)arr from:(int)a to:(int)b{
// arr[a] = @([arr[a] intValue]+[arr[b] intValue]);
// arr[b] = @([arr[a] intValue]-[arr[b] intValue]);
// arr[a] = @([arr[a] intValue]-[arr[b] intValue]);
NSNumber *temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
* 处理枢纽值
*/
- (void)dealPivot:(NSMutableArray *)arr left:(int)left right:(int)right{
int mid = (left + right) / 2;
if (arr[left] > arr[mid]) {
[self swap:arr from:left to:mid];
}
if (arr[left] > arr[right]) {
[self swap:arr from:left to:right];
}
if (arr[right] < arr[mid]) {
[self swap:arr from:right to:mid];
}
[self swap:arr from:right-1 to:mid];
}
- (void)QuickSort:(NSMutableArray *)arr left:(int)left right:(int)right{
if (left < right) {
//获取枢纽值，并将其放在当前待处理序列末尾
[self dealPivot:arr left:left right:right];
//枢纽值被放在序列末尾
int pivot = right - 1;
//左指针
int i = left;
//右指针
int j = right - 1;
while (true) {
while (arr[++i] < arr[pivot]) {
}
while (j > left && arr[--j] > arr[pivot]) {
}
if (i < j) {
[self swap:arr from:i to:j];
} else {
break;
}
}
if (i < right) {
[self swap:arr from:i to:right-1];
}
[self QuickSort:arr left:left right:i-1];
[self QuickSort:arr left:i+1 right:right];
}
}
swift：
func swap(arr:inout Array<Int>,a:Int,b:Int) {
// arr[a] = arr[a]+arr[b];
// arr[b] = arr[a]-arr[b];
// arr[a] = arr[a]-arr[b];
let temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
func dealPivot(arr:inout [Int],left:Int,right:Int){
let mid:Int = (left + right) / 2;
if arr[left] > arr[mid] {
self.swap(arr: &arr, a: left, b: mid)
}
if arr[left] > arr[right] {
swap(arr: &arr, a: left, b: right)
}
if (arr[right] < arr[mid]) {
swap(arr: &arr, a: right, b: mid)
}
swap(arr: &arr, a: right-1, b: mid)
}
func QuickSort(arr:inout [Int],left:Int,right:Int){
if (left < right) {
//获取枢纽值，并将其放在当前待处理序列末尾
dealPivot(arr: &arr, left: left, right: right)
//枢纽值被放在序列末尾
let pivot = right - 1;
//左指针
var i = left;
//右指针
var j = right - 1;
while (true) {
repeat{
i=i+1
}while arr[i] < arr[pivot]
repeat{
j=j-1
}while j > left && arr[j] > arr[pivot]
if i < j {
swap(arr: &arr, a: i, b: j)
} else {
break;
}
}
if i < right {
swap(arr: &arr, a: i, b: right-1)
}
QuickSort(arr: &arr, left: left, right: i-1)
QuickSort(arr: &arr, left: i+1, right: right)
}
}
总结
快速排序是一种交换类的排序，它同样是分治法的经典体现。在一趟排序中将待排序的序列分割成两组，其中一部分记录的关键字均小于另一部分。然后分别对这两组继续进行排序，以使整个序列有序。在分割的过程中，枢纽值的选择至关重要，本文采取了三位取中法，可以很大程度上避免分组"一边倒"的情况。快速排序平均时间复杂度也为O(nlogn)级。
