把递归函数转换成非递归程序的一般方法-优快云博客

本文链接：https://blog.youkuaiyun.com/ma865696/article/details/83769024

递归函数的原理
用栈保存未完成的工作，在适当的时候从栈中取出并执行。
系统保存了工作的数据和状态，数据就是函数的局部变量，
状态就是程序指针。

● 非递归程序原理
1. 和递归函数的原理相同，只不过是把由系统负责保存工作
信息变为程序自己保存，这样能减少保存数据的冗余(主要是
节省了局部变量的空间)，提高存储效率。

2. 把程序要完成的工作分成两类：手头工作和保存在栈中的
待完成的工作。手头工作指程序正在做的工作。由于某些工作
不能一步完成，必须暂缓完成，于是可把它保存在栈中，这就
是待完成的工作。

3. 手头工作必须有其结束条件，不能永远做下去；保存的
待完成工作必须含有完成该项工作的所有必要信息。

4. 程序必须有秩序地完成各项工作。如，可把手头工作恰当
处理（直接处理或暂时保存）后，才能继续接手下一步的工作。

5. 待完成工作必须转换成手头工作才能处理。

● 栈的大小
所有递归问题，其递归过程可以展开成一棵树，叶子节点是
可解的，按照问题的要求，处理所有叶子节点，就可解决
问题本身。可能需要保存(Data, Status)，Data是工作数据，
Status是工作状态；（Data, Status）决定了整个工作。
栈的大小等于树的高度-1，-1是因为根节点不需保存。

● 举例
例1. 汉诺塔问题
递归函数：
void Hanoi(UINT x, UINT y, UINT n)
// x Source
// y Destination
// n Number of plates
{
if (n == 0) return;
Hanoi(x, x^y, n-1);
Move(x, y);
Hanoi(x^y, y, n-1);
}
说明：x、y可取1、2、3三数之一，并且x≠y，x^y表示x、y按位异或，
得到除x、y之外的第三个数。1^2=3, 1^3=2, 2^3=1

非递归程序：
#define N 5
tyepdef struct _HANOIDATA
{
UINT x;
UINT y;
UINT n;
}HANOIDATA;
void Hanoi(HANOIDATA hanoiData)
{
HANOIDATA stack[N];
int top = -1; // stack pointer

while (hanoiData.n || top != -1) // 存在手头工作或待完成工作
{
while (hanoiData.n) // 处理手头工作直到无现成的手头工作，
// 即下次的手头工作必须从栈中取得
{
hanoiData.n --;
stack[++top] = hanoiData; // 保存待完成工作
hanoiData.y ^= hanoiData.x; // 新的手头工作
}
if (top != -1) // 存在待完成工作
{
hanoiData = stack[top--]; // 从栈中取出
Move(hanoiData.x, hanoiData.y); // 直接处理
hanoiData.x ^= hanoiData.y; // 未处理完的转换成手头工作
}
}
}
例2．后根序遍历二叉树
递归函数：
void PostTraverse(BINARYTREE root)
{
if (root == NULL) return;
PostTraverse(root->LChild);
PostTraverse(root->RChild);
Visit(root);
}

非递归程序：
void PostTraverse(BINARYTREE p)
{
while ( p != NULL || !Stack.IsEmpty() )// 存在工作(手头或待完成)
{
while (p != NULL) // 处理手头工作，直到无现成手头工作
{
Stack.Push(p, RCHILD_AND_ITSELF);
p = p->LChild;
}
if (!Stack.IsEmpty()) // 是否存在待完成工作
{
Stack.Pop(p, Tag);
if (Tag == RCHILD_AND_ITSELF) // 情况一: RChild & Itself
{
Stack.Push(p, ONLY_ITSELF) // 保存待完成工作
p = p->RChild; // 新的手头工作
}
else // tag == ONLY_ITSELF, 情况二: Only Itself
{
visit(p);
p = NULL; // 已无现成的手头工作
}
}
}
}

● 总结
非递归程序的设计应注意：
1. 保存暂缓执行的工作
2. 无现成手头工作的条件
3. 无待完成工作的条件

程序模式
void NonRecursiveFunction(DATATYPE Data)
{
while ( ExistHandyWork() || ExistSavedWork() )
{
while ( ExistHandyWork() )
{

Process(Work, Status) // Probably push work onto stack
NewHandyWork();
}
if ( ExistSavedWork() )
{
Pop(Work, Status);
Process(Work, Status); // Probably generate new handy work
}
}
}

用堆栈实现递归其实并没有消除递归，只不过人工做了本来由编译器做的事情。真正的非递归是指运算时所需要的空间是常数，即所需空间与问题的输入规模无关。并非所有递归都可以转换成非递归，比如著名的Ackmann函数。
递归转非递归方法：
（1）用一般公式直接代替。象经常看到的斐波那契数列，它就存在通项公式，而无需采用递归实现。
（2）使用栈来实现
（3）通过Cooper变换、反演变换将一些递归转化为尾递归，从而迭代求出结果
至于什么是Cooper变换，反演变换，这可得好好研究数学。这里贴两个变换实例。

计算阶乘的递归实现（用Haskell实现的，谁都看得懂）：f x ＝ if x = 0 then 1 else f(x-1)*x;
第一步：转变成尾递归

int G(int x, int y)
{
 int x1, y1;

 if (x == 1) {
   return 1 * y;
 } else {   
   x1 = x - 1;
   y1 = x *y;
   return G(x1, y1);
 }
}

int f(int x)
{
 return G(x, 1);
}

第二步：转变成迭代

int G(int x, int y)
{
 int x1, y1;

loop:
 if (x == 1) {
   return 1 * y;
 } else {
   x1 = x - 1;
   y1 = x *y; 
   x = x1
   y = y1;   
   goto loop;
 }
}

求斐波那契值：
f x |x==0 =0
   |x==1 =1
   |otherwise = f (x-1)+f (x-2)

第一步：转变成尾递归
int fib(int n){
   if(n==0)
      return 0;
   return _fib(n,1,0);
}

int _fib(int n,int f1,int f2){
   if(n==1)
      return f1;
   return _fib(n-1,f1+f2,f1);
}

第二步：转变成迭代（略）