快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法
其基本思想为：任取待排序元素序列中的某元素作为基准值(key)，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值(key)，右子序列中所有元素均大于基准值(key)，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
这是测试排序代码的OJ，可以自行测试: 排序OJ
快排时间不够，所以会超出时间限制，知道写没写对即可。
以下三种方法都是基于以上所编写，只是细节不一样：
一.hoare:
步骤如下图：
总结一下就是：(假设右边移动的是right,左边是left)
- right先移动，移动到比key小的时候停下(或right与left相遇的时候停下)
- left再移动，移动到比key大的失时候(或right与left相遇的时候停下)
- 交换下标是left与right的值。
- 重复以上步骤，直到right与left相遇
- 交换下标是key与right(或left)的值。
然后重复以上步骤，直到数组升序。
以上是二叉数的思想，第一次交换完是以下数组：
可以看出6是二叉树的根节点，比6小的都在左边，比6大的都在右边。
一步一步来我们先写第一次排序的代码：
void Swap(int* e1,int* e2)
{
int tmp = *e1;
*e1 = *e2;
*e2 = tmp;
}
void hoarePart(int* nums, int begin,int end)//begin是数组最左边，end是最右边的下表
{
int key = begin;
int left = begin;
int right = end;
while (right > left)
{
while (right > left && nums[right] >= nums[key])
{
right--;
}
while (right > left && nums[left] <= nums[key])
{
left++;
}
if (right > left)
{
Swap(&nums[right], &nums[left]);
}
}
Swap(&nums[right], &nums[key]);
}
然后要重复至数组升序，运用了二叉树的递归：
void Swap(int* e1,int* e2)
{
int tmp = *e1;
*e1 = *e2;
*e2 = tmp;
}
int hoarePart(int* nums, int begin,int end)
{
int key = begin;
int left = begin;
int right = end;
while (right > left)
{
while (right > left && nums[right] >= nums[key])
{
right--;
}
while (right > left && nums[left] <= nums[key])
{
left++;
}
if (right > left)
{
Swap(&nums[right], &nums[left]);
}
}
Swap(&nums[right], &nums[key]);
return right;
}
void QuickSort(int* nums,int begin,int end)
{
if (begin >= end)
{
return;
}
int key = hoarePart(nums,begin,end);//这里需要记录key的位置
QuickSort(nums,begin,key-1);
QuickSort(nums, key+1, end);
}
这串代码还有优化，因为如果排序的数组已经是升序，那么遍历的时间复杂度就是O(n^2),例子如下：key只会+1+1这样，right也会从右边遍历到最左边
所以在选key上做了优化：取下表为begin,mid,end中间的值就不会发生这种极端情况：
int GetMid(int* nums,int begin,int end)
{
int mid = (begin + end) / 2;
if (nums[begin] > nums[mid])
{
if (nums[mid] > nums[end])
{
return mid;
}
else if(nums[begin] < nums[end])
{
return begin;
}
else
{
return end;
}
}
else //nums[mid] > nums[begin]
{
if (nums[mid] < nums[end])
{
return mid;
}
else if (nums[begin] > nums[end])
{
return begin;
}
else
{
return end;
}
}
}
void Swap(int* e1,int* e2)
{
int tmp = *e1;
*e1 = *e2;
*e2 = tmp;
}
int hoarePart(int* nums, int begin,int end)
{
int mid = GetMid(nums,begin,end);
Swap(&nums[begin],&nums[mid]);
int key = begin;
int left = begin;
int right = end;
while (right > left)
{
while (right > left && nums[right] >= nums[key])
{
right--;
}
while (right > left && nums[left] <= nums[key])
{
left++;
}
if (right > left)
{
Swap(&nums[right], &nums[left]);
}
}
Swap(&nums[right], &nums[key]);
return right;
}
void QuickSort(int* nums,int begin,int end)
{
if (begin >= end)
{
return;
}
int key = hoarePart(nums,begin,end);
QuickSort(nums,begin,key-1);
QuickSort(nums, key+1, end);
}
快速排序的特性总结：
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
二. 挖坑法:
这个相比较hoare法就是把key下标的形式改为数值的形式，和hoare法差不多
int GetMid(int* nums,int begin,int end)
{
int mid = (begin + end) / 2;
if (nums[begin] > nums[mid])
{
if (nums[mid] > nums[end])
{
return mid;
}
else if(nums[begin] < nums[end])
{
return begin;
}
else
{
return end;
}
}
else //nums[mid] > nums[begin]
{
if (nums[mid] < nums[end])
{
return mid;
}
else if (nums[begin] > nums[end])
{
return begin;
}
else
{
return end;
}
}
}
void Swap(int* e1,int* e2)
{
int tmp = *e1;
*e1 = *e2;
*e2 = tmp;
}
int PartSort2(int* a, int begin, int end)
{
int midi = GetMid(a, begin, end);
Swap(&a[midi], &a[begin]);
int key = a[begin];
int hole = begin;
while (begin < end)
{
// 右边找小，填到左边的坑
while (begin < end && a[end] >= key)
{
--end;
}
a[hole] = a[end];
hole = end;
// 左边找大，填到右边的坑
while (begin < end && a[begin] <= key)
{
++begin;
}
a[hole] = a[begin];
hole = begin;
}
a[hole] = key;
return hole;
}
void QuickSort(int* nums,int begin,int end)
{
if (begin >= end)
{
return;
}
int key = PartSort2(nums,begin,end);
QuickSort(nums,begin,key-1);
QuickSort(nums, key+1, end);
}
这种方法和hoare法差不多，就不再细说。
三.前后指针版本:
方法都差不多所以就不说了。注意的点写注释了。思路一样就行，代码一样不一样无所谓
参考代码如下；
int GetMid(int* nums,int begin,int end)
{
int mid = (begin + end) / 2;
if (nums[begin] > nums[mid])
{
if (nums[mid] > nums[end])
{
return mid;
}
else if(nums[begin] < nums[end])
{
return begin;
}
else
{
return end;
}
}
else //nums[mid] > nums[begin]
{
if (nums[mid] < nums[end])
{
return mid;
}
else if (nums[begin] > nums[end])
{
return begin;
}
else
{
return end;
}
}
}
void Swap(int* e1,int* e2)
{
int tmp = *e1;
*e1 = *e2;
*e2 = tmp;
}
int QuickSortPart3(int* nums, int begin, int end)
{
int mid = GetMid(nums, begin, end);
Swap(&nums[begin], &nums[mid]);
int key = begin;
int cur = key + 1;
int prev = begin;
while (cur <= end)
{
if (nums[cur] < nums[key] && cur != ++prev)//这里是先要判断nums[cur]是不是大于nums[key]，再进行下一步，注意cur != prev + 1的时候才交换
{
Swap(&nums[cur], &nums[prev]);
}
cur++;
}
Swap(&nums[key], &nums[prev]);
return prev;
}
void QuickSort(int* nums,int begin,int end)
{
if (begin >= end)
{
return;
}
int key = QuickSortPart3(nums,begin,end);
QuickSort(nums,begin,key-1);
QuickSort(nums, key+1, end);
}
四.三种方法的性能比较：
这是测试一千万个数据的比较，相差不大
测试代码如下：（三种排序的代码就不重新写了）
void TestOP()
{
srand(time(0));
const int N = 10000000;//数据的个数在这里可以改
int* a1 = (int*)malloc(sizeof(int) * N);
int* a2 = (int*)malloc(sizeof(int) * N);
int* a3 = (int*)malloc(sizeof(int) * N);
for (int i = 0; i < N; ++i)
{
a1[i] = rand();
a2[i] = a1[i];
a3[i] = a1[i];
}
int begin1 = clock();
QuickSort1(a1, 0,N-1);
int end1 = clock();
int begin2 = clock();
QuickSort2(a2, 0, N-1);
int end2 = clock();
int begin3 = clock();
QuickSort3(a3, 0, N-1);
int end3 = clock();
printf("QuickSort1:%d\n", end1 - begin1);//快速排序--hoare法
printf("QuickSort2:%d\n", end2 - begin2);//快速排序--挖坑法
printf("QuickSort3:%d\n", end3 - begin3);//快速排序--前后指针
free(a1);
free(a2);
free(a3);
}
五.非递归的形快速排序：
常见的递归转非递归就两种：
- 循环，就像斐波那契数列的递归转非递归
- 栈，就是二叉树的递归
简单讲解一下思路：
递归的时候主要是以二叉树为主，写递归的时候第一步是找区间，第二步再排序，所以栈一样，如下图：
然后一直重复，直到栈空了为止，当然有些时候不用入栈的，比如下列情况
其中最重要的就是入栈出栈顺序要掌握好，不能乱
代码如下：（因为用C写的所以得造轮子）
//栈的轮子：
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}Stack;
//初始化栈
void StackInit(Stack* ps)
{
assert(ps);
ps->a = NULL;
ps->top = -1;
ps->capacity = 0;
}
//销毁栈
void StackDestory(Stack* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->top = -1;
}
//入栈
void StackPush(Stack* ps, STDataType x)
{
assert(ps);
if (ps->capacity == ps->top + 1)
{
int Newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(Stack) * Newcapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
ps->a = tmp;
ps->capacity = Newcapacity;
}
ps->top++;
ps->a[ps->top] = x;
}
//判断为空
bool StackEmpty(Stack* ps)//栈为空返回真
{
return ps->top == -1;
}
//栈中元素个数
int StackSize(Stack* ps)
{
assert(ps);
return ps->top + 1;
}
//删除栈顶元素
void StackPop(Stack* ps)
{
assert(ps);
assert(ps->top != -1);
ps->top--;
}
//获得栈顶元素
STDataType StackTop(Stack* ps)
{
assert(ps);
//结构体不能为空
assert(ps->top != -1);
return ps->a[ps->top];
}
//快速排序非递归的部分
void Swap(int* e1, int* e2)
{
int tmp = *e1;
*e1 = *e2;
*e2 = tmp;
}
void QuickSortR(int* nums, int begin, int end)
{
Stack ST;
StackInit(&ST);
StackPush(&ST, begin);
StackPush(&ST, end);
while (!StackEmpty(&ST))
{
int right = StackTop(&ST);
StackPop(&ST);
int left = StackTop(&ST);
StackPop(&ST);
int key = QuickSortPart3(nums, left, right);
if (right > key+1)
{
StackPush(&ST, key+1);
StackPush(&ST, right);
}
if (left < key-1)
{
StackPush(&ST, left);
StackPush(&ST, key - 1);
}
}
StackDestory(&ST);
}
如果有上面错误，请大佬指出
680
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
