一、快速排序的思想
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
二、快速排序的三种实现方法
2.1、Hoare
思想：取最左边key为基准值，用right指针找比key值小的元素，用left指针找比key位置大的元素，
将两位置值进行交换，最后，将key值放在二者相遇位置上，就可保证key左边都是比key小的值，
右边都是比key大的值，然后进行递归即可实现，从相遇点分割成两部分，在分别对左右两部分重
复上述排序。
代码实现 ：
void Swap(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
//Hoare
int partSort1(int* a, int left, int right)
{
int key = left;
while (right > left)
{
//从右往左找小
while (right > left && a[right] >= a[key])
{
right--;
}
//从左往右找大
while (right > left && a[left] <= a[key])
{
left++;
}
Swap(&a[left], &a[right]);
}
Swap(&a[left], &a[key]);
return left;
}
void QuickSort(int* arr, int begin,int end)
{
if (begin >= end)
{
return;
}
int keyi = partSort1(arr, begin, end);
QuickSort(arr, begin, keyi - 1);
QuickSort(arr, keyi + 1, end);
}
2.2、挖坑法
思想：取最左边或最右边值做key，右边形成一个坑，定义两个指针left、right指向头和尾。右边找
小值放到左边坑中右边形成新坑，左边找大值放到右边左边形成新坑，将key放到相遇位置。这时
key左边值均小于key，右边值均大于key。
代码实现：
void Swap(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
//挖坑法
int partSort2(int* a, int left, int right)
{
int hole = left;
int key = a[left];
while (right > left)
{
//从右往左找小
while (right > left && a[right] >= key)
{
right--;
}
a[hole] = a[right];
hole = right;
//从左往右找大
while (right > left && a[left] <= key)
{
left++;
}
a[hole] = a[left];
hole = left;
}
a[hole] = key;
return hole;
}
void QuickSort(int* arr, int begin,int end)
{
if (begin >= end)
{
return;
}
int keyi = partSort2(arr, begin, end);
QuickSort(arr, begin, keyi - 1);
QuickSort(arr, keyi + 1, end);
}
2.3、双指针法
思想：
1.选择数组中的第一个元素arr[startIndex]作为轴（pivot）
2.左指针为left，从最左边开始寻找第一个比pivot大的数
3.右指针为right，从最右面的一个元素开始向左寻找第一个小于等于pivot的数值
4.经过2，3两个步骤后，将会出现以下两种情况
（1）：left和right没有相遇，此时进行交换，swap（arr,left,right）;
（2）：left和right相遇，做swap（arr,startIndex,left），然后返回left
5.partition中返回pivot用于分割数组，下一次用于排序的数组被分割为(startIndex,pivot-1),(pivot+1,endIndex)两段，进行递归操作
代码实现：
void Swap(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int partSort3(int* a, int left, int right)
{
int prev = left;
int cur = prev + 1;
int key = left;
while (cur <= right)
{
if (a[cur] < a[key] && ++prev != cur)
{
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[prev], &a[key]);
return prev;
}
void QuickSort(int* arr, int begin,int end)
{
if (begin >= end)
{
return;
int keyi = partSort3(arr, begin, end);
QuickSort(arr, begin, keyi - 1);
QuickSort(arr, keyi + 1, end);
}三、快速排序的优化
3.1、三数取中
当要排序的数组有序或者相对有序，比如我们要把一个逆序的数组按顺序排列，这时我们如果还选
择left为key的话，效率就会非常的低。我们要排除这种低效的可能就要让Key的值相对靠中间一
点，对此我们可以在实现一个函数，选择处left ,right ，和mid三个数中数值中间的那个数。用这个
数作为key就会避免我们遇到的这类问题。
代码实现：
//三数取中
int Getmid(int* a, int left, int right)
{
int mid = (left + right) / 2;
// left mid right
if (a[left] < a[mid])
{
if (a[mid] < a[right])
{
return mid;
}
else if (a[left] > a[right]) // mid是最大值
{
return left;
}
else
{
return right;
}
}
else // a[left] > a[mid]
{
if (a[mid] > a[right])
{
return mid;
}
else if (a[left] < a[right]) // mid是最小
{
return left;
}
else
{
return right;
}
}
}对此我们就可以改进上面的三种方法，都可以在三种方法的开头添加这段代码，使之让key为靠中间的数，避免数组为有序的排序时间效率低的问题。
int midi = Getmid(a, left, right);
Swap(&a[left], &a[midi]);3.2、小区间优化
我们递归的深度越高效率越高，但是我们刚开始递归时深度很低，所以效率低下，所以我们可以采用高深度的时候用快速排序，在低深度的时候用直接插入排序，会对运行效率有所提高。
void QuickSort(int* a, int begain, int end)
{
if (begain >= end)
return;
//小区间优化法 当数据量比较大的时候可以通过调整参数(20),来减小递归次数，提高性能
if ((end - begain) > 20)
{
int meeti = HoareSort(a, begain, end);
QuickSort(a, begain, meeti - 1);
QuickSort(a, meeti + 1, end);
}
else
{
//数量比较少的时候用直接插入来排序
InsertSort(a + begain, end - begain + 1);
}
}
四、非递归实现快速排序
递归需要在栈上为函数开辟空间，32位下，栈可使用的内存大小不超过2G，如果递归较深，依然可能会发生栈溢出，这个时候递归排序就不大适用，所以需要非递归出场。
利用栈来存储区间下标，代码如下：要注意先数组头，后入数组尾。出栈时栈顶的数据为数组尾，在出才为头位置下标。
代码如下：
//交换函数
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
//三数取中
int GetMinIndex(int* arr, int left, int right)
{
int mid = (left + right) >> 1;
if (arr[left] < arr[mid])
{
if (arr[mid] < arr[right])
{
return mid;
}
if (arr[left] < arr[right] && arr[right] < arr[mid])
{
return right;
}
return left;
}
else//arr[left] >= arr[mid]
{
if (arr[left] < arr[right])
{
return left;
}
if (arr[mid] < arr[right] && arr[right] < arr[left])
{
return right;
}
return mid;
}
}
//快排非递归
void QuickSort(int* arr, int n)
{
ST st;
StackInit(&st);
//把左右区间压栈，先压右边
StackPush(&st, n - 1);
//后压左边
StackPush(&st, 0);
//只要栈不为空，就继续分割排序
while (!StackEmpty(&st))
{
//从栈里面取出左右区间
int left = StackTop(&st);
StackPop(&st);
int right = StackTop(&st);
StackPop(&st);
int index = GetMinIndex(arr, left, right);
//因为我们下面的逻辑都是把第一个数作为key，
//为了避免改动代码，这里我们直接交换就可以
Swap(&arr[left], &arr[index]);
//开始单趟排序
int begin = left;
int end = right;
int pivot = begin;
int key = arr[begin];
while (begin < end)
{
//end开始找小
while (begin < end && arr[end] >= key)
{
end--;
}
arr[pivot] = arr[end];
pivot = end;
//begin开始找大
while (begin < end && arr[begin] <= key)
{
begin++;
}
arr[pivot] = arr[begin];
pivot = begin;
}
pivot = begin;
arr[pivot] = key;
//区间分为[left,pivot-1]pivot[pivot+1,right]
//利用循环继续分割区间
//先入右子区间
if (pivot + 1 < right)
{
//说明右子区间不止一个数
//先入右边边界
StackPush(&st, right);
//再入左边边界
StackPush(&st, pivot+1);
}
//再入左子区间
if (left < pivot-1)
{
//说明左子区间不止一个数
//先入右边边界
StackPush(&st, pivot-1);
//再入左边边界
StackPush(&st, left);
}
}
StackDestory(&st);
}
五、时间复杂度
快速排序的时间复杂度：
最坏情况下，时间复杂度是O(n^2); （逆序）
最优情况下，时间复杂度是O(nlogn);
平均时间复杂度是O(nlogn);
快速排序是时间复杂度：O(logn)
539
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
