快排的思想
首先 快排是一种比较排序。
具体思想是 选出一个基准值,通过比较找出待排序区间中基准值该放置的位置。
实现逻辑:
- 先从数列中取出一个数作为基准数(通常取第一个数)。
- 分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。
- 再对左右区间重复第二步,直到各区间只有一个数。
分区的三种方式
通常有三种方式来进行基准数的左右分区。
- 左右指针法。
- 挖坑法
- 前后指针法。
左右指针实现:
//左右指针法
int PartSort(int* a, int begin, int end) {// 降序
int key = a[end];
int index = end;
while (begin < end){
while(begin < end && a[begin] <= key){
++begin;
}
while(begin < end && a[end] >= key){
--end;
}
swap(a[begin], a[end]);
}
swap(a[begin], a[index]);
return begin;
}
挖坑法实现:
//挖坑法
int PartSort2(int* a, int begin, int end) {//降序
int key = a[end];
while (begin < end){
while(begin < end && a[begin] <= key){
++begin;
}
a[end] = a[begin];
while (a[begin] < a[end] && a[end] >= key){
--end;
}
a[begin] = a[end];
}
a[begin] = key;
return begin;
}
前后指针法实现:
//前后指针法 思路cur一直向前走遇到小的就置换到前面 这样一来 一次循环 就达到目的
int PartSort3(int* a, int begin, int end) {//降序
int key = a[end];
int prev = begin - 1;
int cur = begin;
while (cur < end){
if (a[cur] < key && ++prev != cur) {
swap(a[cur], a[prev]);
}
++cur;
}
++prev;
swap(a[prev], a[end]);
return prev;
}
递归与非递归实现
递归:
void QuickSort(int* a, int begin, int end) {
if (begin >= end){
return;
}
int mid = PartSort(a, begin, end);//也可以写进函数内部
QuickSort(a, begin, mid-1);
QuickSort(a, mid+1, end);
}
迭代:
void QuickOfStack(int* a, int n) {
int begin = 0;
int end = n-1;
stack<int> s1;
s1.push(begin);
s1.push(end);
while(!s1.empty()) {
int right = s1.top();
s1.pop();
int left = s1.top();
s1.pop();
int mid = PartSort(a, left, right);
if (left < mid-1) {
s1.push(left);
s1.push(mid-1);
}
if (mid+1 < end){
s1.push(mid+1);
s1.push(right);
}
}
}
空间复杂度,主要是递归造成的栈空间的使用,最好情况,递归树的深度不深
其空间复杂度也就为 O(logn),
最坏情况,
需要进行n‐1递归调用,其空间复杂度为O(n),
平均情况,
空间复杂度也为O(logn)。
快排的优化
快排的平均时间复杂度是O(nlogn), 但是最坏的情况下,也就是有序的情况下回达到n^2的复杂度,因此我们考虑快排进行优化。为了避免有序情况下每次都取到最大值或者最小值。因此提出了三数取中的方法。
int SelectMid(int* a, int begin, int end) {//返回中间大小的下标
int mid = (begin+end) >> 1;
if (a[begin] >= a[mid] && a[mid] >= a[end]) {
return mid;
}else if (a[mid] >= a[begin] && a[begin] >= a[end]) {
return begin;
}
return end;
}
稳定性: 快排是一种不稳定的算法。
时间复杂度:O(nlogn)
空间复杂度:O(logn)