递归转化为非递归
- 前言
- 快速排序非递归
- 归并排序的非递归
前言
为什么要学习非递归写法呢？
当我们在用递归实现一个程序的时候，要考虑一个问题，这个程序用递归去实现，当数据量庞大的时候，会不会造成栈溢出(STACK OVERFLOW)呢？
如果没有造成还好，造成了怎么解决这个问题呢？这个时候就需要用到非递归，把一个递归实现的程序转化为非递归，是一个程序猿的基本功。
int Sum(int n)
{
if (n == 1)
{
return 1;
}
return n + Sum(n - 1);
}
int main()
{
int ret = Sum(100);
cout << ret;
return 0;
}
比如这个代码，把这个代码转化为非递归特别简单，一个for循环即可搞定。
int ret = 0;
for (int i = 1; i <= 100; i++)
{
ret += i;
}
cout << ret;
那么一个复杂的代码呢？比如快速排序，归并排序
快速排序非递归
快速排序在递归的时候，每次都是把区间压入栈中，
这是一个快排的代码，前后指针版本的。
从代码的最后，每次都是把基准值的左面先压入栈中，然后在继续划分，直到不能在划分为止，这个时候，就开始划分基准值的右面，直到完成排序。根据这个思想我们可以考虑手动模拟一个栈，然后用非递归来实现快排。
C++有库函数可以直接使用，在这里就不再写栈是怎么实现的了，不会的点击->传送门。
因为是把栈的左右区间压入，还要在定义一个pair<int,int>,不知道这个是什么的，也可以使用结构体，让结构体里面存左右区间也行
typedef pair<int, int> PII;
typedef struct Stack
{
int l, r;
}stk;
- 首先，把最开始的区间压入栈中，然后以栈是否为空做为循环条件进行判断
- 定义临时变量存储左(begin)右(end)区间，然后用我们之前学过的快排，来模拟这一过程，快排里不在使用递归。
- 将区间划分，并压入栈中
- 重复2和3，直到循环结束，此时排序完成
代码如下
//挖坑法的快排代码
int PartSort2(int* a, int l, int r)
{
//if (l >= r)
//{
// return;
//}
int key = a[l];
int hole = l;
int bg = l;
int ed = r;
while (l < r)
{
while (l < r && a[r] >= key)
{
r--;
}
a[hole] = a[r];
hole = r;
while (l < r && a[l] <= key)
{
l++;
}
a[hole] = a[l];
hole = l;
}
a[hole] = key;
return hole;
}
//非递归形式实现快排
void QuickSort(int* a, int l, int r)
{
stack<PII> stk;
stk.push({ l, r });
while (!stk.empty())
{
auto t = stk.top();
stk.pop();
int begin = t.first;
int end = t.second;
if (begin >= end)
{
continue;
}
int key_i = PartSort2(a, begin, end);
stk.push({ begin,key_i - 1 });
stk.push({ key_i + 1, end });
}
}
归并排序的非递归
归并排序的非递归，这玩意有难度，学了好久才学会。
归并排序并不是用栈去实现的，因为归并排序是八一个序列分成n个子序列，然后归并归并归并，得到一个呈上升或者下降的序列，从这里，我们可以考虑直接从n个子序列开始归并，类似于树的后续遍历。
这里就要个问题了，归并排序需要一个临时数组，然后把临时数组赋值给原数组，从而得到有序序列，那么，这个拷贝的过程是一次性拷贝完，还是归并一次拷贝一次呢？
答案是这两种方式都可以，直接拷贝完的话呢，需要考虑的情况有点多，不推荐，归并一次拷贝一次最好。
- 首先定义一个gap，gap表示几几归并，刚开始肯定是一一归并，然后二二归并，四四归并
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;//建议自己手动模拟一下这个过程
- 对边界问题进行修正
if (end1 >= n || begin2 >= n)
{
break;
}
if (end2 >= n)
{
end2 = n - 1;
}
- 开始归并
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
- 将临时数组拷贝到原数组中
memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
- 将gap扩大
gap *= 2;
- 重复上述2，3，4，5，6操作
- 释放掉临时数组
free(tmp);
代码如下
void UMergeSort(int* a, int n ,int* tmp)
{
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;
if (end1 >= n || begin2 >= n)
{
break;
}
if (end2 >= n)
{
end2 = n - 1;
}
int j = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
{
tmp[j++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[j++] = a[begin2++];
}
memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
}
gap *= 2;
}
free(tmp);
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * (n));
UMergeSort(a, n,tmp);
}
