快排的小区间优化:
原因:
递归分割的最后三层花费了大量的时间
解决方案:
思路:
递归分割过程,区间比较小以后,不再递归分割排序,大概十个数以内。
代码:
//前后指针法
int PartSort3(int* a, int left, int right)
{
int midi = GetMid(a, left, right);
Swap(&a[left], &a[midi]);
int prev = left;
int cur = prev + 1;
int keyi = left;
while (cur <= right)
{
if (a[cur] < a[keyi])
{
prev++;
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[prev], &a[keyi]);
return prev;
}
//快速排序递归实现
//[begin, end]
void QuickSort1(int* a, int begin, int end)
{
if (begin >= end)
{
return;
}
//小区间优化,小区间不再递归分割排序,降低递归次数
if ((end - begin + 1) > 10)
{
int keyi = PartSort3(a, begin, end);
//[begin, keyi - 1] keyi [keyi + 1, end]
QuickSort1(a, begin, keyi - 1);
QuickSort1(a, keyi + 1, end);
}
else
{
InsertSort(a + begin, end - begin + 1);
}
}
//时间复杂度:O(N*logN)
//空间复杂度:O(logN) ps:看深度 空间重复利用
//稳定性:不稳定
主要是理解小区间优化,快排的实现有三种方法但是不是本章重点不做过多讲解。
非递归实现快排
为什么要学会非递归?
快排可能有爆栈的风险,但是有二分查找一般不会爆
作为程序员一定要会把递归改成非递归
思路:
先进右边再进左边
入栈:先右再左,至少有两个值,通过调试观测一下过程
核心代码:
void QuickSortNonR(int* a, int begin, int end)
{
ST st;
STInit(&st);
STPush(&st, end);
STPush(&st, begin);
while (!STEmpty(&st))
{
int left = STTop(&st);
STPop(&st);
int right = STTop(&st);
STPop(&st);
//单趟排序
int keyi = PartSort3(a, left, right);
//[left, keyi - 1] key[keyi + 1, right]
//先传右边再传左边
if (keyi + 1 < right)
{
STPush(&st, right);
STPush(&st, keyi + 1);
}
if (left < keyi - 1)
{
STPush(&st, keyi - 1);
STPush(&st, left);
}
}
STDestroy(&st);
}
因为用栈完成的,所以在这之前要造个轮子也就是要进行栈的声明和定义。
理想情况下的归并排序
思路:
归并到tmp数组再拷贝回去,一个一个归并下来,拷贝回去,两个两个归并,再拷贝回去。走后序左区间右区间有序再归并,如何有序递归子问题让它有序,不断分割分到最小区间再往回走
代码:
void _MergeSort(int* a, int* tmp, int begin, int end)
{
//分割条件
if (end <= begin)
{
return;
}
int mid = (begin + end) / 2;
//走后序分割
//[begin, mid][mid+1, end],直接分成两半
_MergeSort(a, tmp, begin, mid);
_MergeSort(a, tmp, mid + 1, end);
//归并到tmp数组,再拷贝回去
//a-> [begin, mid][mid+1, end] ->tmp
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int index = begin;
//写的是继续的条件,取小的尾插 ,有一个结束了才结束。
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
//还有没结束的就把剩余的尾插
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
//拷贝回原数组
memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
// 归并排序递归实现
void MergeSort(int* a, int n)
{
//1.需要一个新数组
int* tmp = (int*)malloc(sizeof(int)*n);
if (tmp == NULL)
{
perror("malloc fail");
exit(-1);
}
//2.要写子函数
_MergeSort(a, tmp, 0, n - 1);
free(tmp);
}
原数组归并可能会覆盖,所以要用第三方来进行。
归并排序非递归实现
思路:
代码:
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
// [begin1,end1] [begin2,end2] 归并
int index = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
// 拷贝回原数组
memcpy(a + i, tmp + i, (2 * gap) * sizeof(int));
}
gap *= 2;
}
free(tmp);
}
总结:
难理解的地方就画递归展开图理解,理想情况下归并排序非递归实现还是很容易理解的,但是当数据是9个或者10个等不能取整的时候就要修正下标了,会在理想情况下的代码基础上做出一些小修改。