递归转循环的通用方法

转载请注明出处：http://blog.csdn.net/tobewhatyouwanttobe/article/details/51180977

1.递归

定义：程序调用自身的编程技巧称为递归。

栈与递归的关系：递归是借助于系统栈来实现的。每次递归调用，系统都要为该次调用分配一系列的栈空间用于存放此次调用的相关信息：返回地址，局部变量等。当调用完成时，就从栈空间内释放这些单元，在该函数没有完成前，分配的这些单元将一直保存着不被释放。


2.递归转化为循环

记得有人说过“所有递归都能转化为循环”，某晚睡不着思考了一下这个问题，通过几天的努力，查阅了一些资料，这里结合三个例子给出解决思路，欢迎讨论。

既然系统是根据栈来实现递归的，我们也可以考虑模拟栈的行为来将递归转化为循环，

比如二叉树的中序遍历代码：


我们可以建个栈，栈保存每次递归的状态（结构体record），包括所有局部变量的值。
现在有两个问题：
1.怎样模拟递归的调用，当前进入哪个递归环境。
2.怎样保证栈中状态出入栈的顺序和递归的顺序一致。


问题1：我们用一个record cur来记录当前的递归环境，相当于每次递归的传参，发生递归调用时改变cur相应的值。
问题2：我们将这个递归函数划分为（递归调用+1）种情况，如上图划分为3种情况，state0：进入pos->le递归;state1:输出当前点，进入pos->ri递归;state2：返回。当进入一个递归体时，遇到递归dg1，处理该state应该做的事，然后构造该递归状态和state，入栈，再更新cur进入下一层。

因为cur进入下一层后的递归都要比dg1先执行（即cur进入下一层后的递归全部返回后才执行dg1），栈是先进后出，所以我们将该递归状态入栈能够保证第二点。如果一个调用结束了，就需要返回上一层，即本例的state2，作用相当于确定当前进入哪个递归环境，当前肯定是进入栈顶环境，直接将栈顶的记录弹出，来更新cur即可。说的有点多，结合完整代码看更好懂一些。


3.二叉树遍历代码：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stack>
  4. #include <algorithm>
  5. using namespace std;
  6.  
  7. struct node
  8. {
  9.     int val;
  10.     node *le,*ri;
  11. };
  12. struct record
  13. {
  14.     node* a;
  15.     int state;
  16.     record(node* a,int state):a(a),state(state) {}
  17. };
  18.  
  19. void non_recursive_inorder(node* root) //循环中序遍历
  20. {
  21.     stack<record> s;
  22.     node* cur=root;   //初始化状态
  23.     int state=0;
  24.     while(1)
  25.     {
  26.         if(!cur)                 //如果遇到null结点，返回上一层 对应递归中的if(pos==NULL) return ;
  27.         {
  28.             if(s.empty()) break; //如果没有上一层，退出循环
  29.             cur=s.top().a;
  30.             state=s.top().state; //返回上层状态
  31.             s.pop();
  32.         }
  33.         else if(state == 0)      //state0，执行第一个递归inorder(cur->le);
  34.         {
  35.             s.push(record(cur,1));//保存本层状态
  36.             cur=cur->le;        //更新到下层状态
  37.             state=0;
  38.         }
  39.         else if(state == 1)        //state1，执行print和inorder(cur->ri)
  40.         {
  41.             printf("%d ",cur->val);
  42.             s.push(record(cur,2));   //保存本层状态
  43.             cur=cur->ri;         //进入下层状态
  44.             state=0;
  45.         }
  46.         else if(state == 2)        //state2，函数结束，返回上层状态
  47.         {
  48.             if(s.empty())break;    //初始结点的退出状态，遍历结束
  49.             cur=s.top().a;         //返回上层状态
  50.             state=s.top().state;
  51.             s.pop();
  52.         }
  53.     }
  54.     putchar('
');
  55. }
  56.  
  57. void build(node **pos,int val)  //建二叉树
  58. {
  59.     if(*pos==NULL)
  60.     {
  61.         *pos=(node *)malloc(sizeof(node));
  62.         (*pos)->val=val;
  63.         (*pos)->le=(*pos)->ri=NULL;
  64.         return ;
  65.     }
  66.     if(val<(*pos)->val) build(&((*pos)->le),val);
  67.     else if(val>(*pos)->val) build(&((*pos)->ri),val);
  68. }
  69. void Del(node *pos)  //删除二叉树
  70. {
  71.     if(pos==NULL) return;
  72.     Del(pos->le);
  73.     Del(pos->ri);
  74.     free(pos);
  75. }
  76. void visit_mid(node *pos) //递归中序遍历
  77. {
  78.     if(pos==NULL) return ;
  79.     visit_mid(pos->le);
  80.     printf("%d ",pos->val);
  81.     visit_mid(pos->ri);
  82. }
  83. int main()
  84. {
  85.     int i,n,x;
  86.     while(~scanf("%d",&n))
  87.     {
  88.         node *root=NULL;
  89.         for(i=1; i<=n; i++)
  90.         {
  91.             scanf("%d",&x);
  92.             build(&root,x);
  93.         }
  94.         puts("递归中序遍历:");
  95.         visit_mid(root);
  96.         puts("");
  97.         puts("循环中序遍历:");
  98.         non_recursive_inorder(root);
  99.         Del(root);
  100.     }
  101.     return 0;
  102. }
  103. /*
  104. 9
  105. 5 2 1 4 3 8 6 7 9
  106. */

可以画出递归的调用和返回的图，手动模拟代码运行，看每一步cur和栈里面的状态时怎样的，能够帮助更好的理解这种思想。

若要将中序改成先序和后序，也只用改变代码中的printf的位置即可，知道每个state要做什么事情就行。


4.快速排序：

快速排序是分治、递归经典应用，一般的写法都是递归，因为其代码简单易懂，我们不妨也用上述思路来转化为循环版本，因为递归的形式和二叉树的遍历基本一致，也只需划分为3种情况即可。

代码：

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <cstring>
  4. #include <stack>
  5. #define maxn 1005
  6. using namespace std;
  7.  
  8. int a[maxn];
  9.  
  10. struct record
  11. {
  12.     int le,ri,state;
  13.     record(int le=0,int ri=0,int state=0):le(le),ri(ri),state(state){}
  14. };
  15.  
  16. int Partition(int le,int ri) //划分
  17. {
  18.     int tmp=a[le],pos=le;
  19.     while(le<ri)
  20.     {
  21.         while(le<ri&&a[ri]>=tmp) ri--;
  22.         a[pos]=a[ri];
  23.         pos=ri;
  24.         while(le<ri&&a[le]<=tmp) le++;
  25.         a[pos]=a[le];
  26.         pos=le;
  27.     }
  28.     a[pos]=tmp;
  29.     return pos;
  30. }
  31. void Qsort(int le,int ri) //递归版本
  32. {
  33.     if(le<ri)
  34.     {
  35.         int p=Partition(le,ri);
  36.         Qsort(le,p-1);
  37.         Qsort(p+1,ri);
  38.     }
  39. }
  40. void QsortLoop(int n) //循环版本
  41. {
  42.     int i;
  43.     record cur(1,n,0),now;
  44.     stack<record>s;
  45.     while(1)
  46.     {
  47.         //getchar();
  48.         //printf("%d %d %d
",cur.le,cur.ri,cur.state);
  49.         if(cur.le<cur.ri)
  50.         {
  51.             if(cur.state==0) //划分 向下递归 保存本层下次递归状态
  52.             {
  53.                 int p=Partition(cur.le,cur.ri);
  54.                 now.le=p+1; now.ri=cur.ri; now.state=1;
  55.                 s.push(now);
  56.                 cur.ri=p-1;
  57.             }
  58.             else if(cur.state==1) //向下递归 保存本层下次递归状态
  59.             {
  60.                 now=cur; now.state=2;
  61.                 s.push(now);
  62.                 cur.state=0;
  63.             }
  64.             else
  65.             {
  66.                 if(s.empty()) break ; //栈内没有节点退出
  67.                 cur=s.top();
  68.                 s.pop();
  69.             }
  70.         }
  71.         else //递归返回
  72.         {
  73.             if(s.empty()) break ; //栈内没有节点退出  不加这句可以试一试2 1 2
  74.             cur=s.top();
  75.             s.pop();
  76.         }
  77.     }
  78. }
  79. int main()
  80. {
  81.     int i,n;
  82.     while(~scanf("%d",&n))
  83.     {
  84.         for(i=1;i<=n;i++) scanf("%d",&a[i]);
  85.         //Qsort(1,n);
  86.         QsortLoop(n);
  87.         for(i=1;i<=n;i++)
  88.         {
  89.             printf("%d ",a[i]);
  90.         }
  91.         puts("");
  92.     }
  93.     return 0;
  94. }
  95. /*
  96. 5
  97. 1 2 3 4 5
  98. 7
  99. 5 10 8 6 3 20 2
  100. 6
  101. 64 5 3 45 6 78
  102. */

5.输出1~n的全排列。

首先来看一下循环的版本，初始化vis为0，调用dfs(n)即可得到结果：

  1. int res[maxn];    //答案数组
  2. bool vis[maxn];   //标记数组
  3. void dfs(int pos) //当前进行到pos位置
  4. {
  5.     if(pos==n+1)  //为n+1则得到了一组答案 输出
  6.     {
  7.         for(int i=1; i<=n; i++)
  8.         {
  9.             printf("%d ",res[i]);
  10.         }
  11.         puts("");
  12.     }
  13.     for(int i=1; i<=n; i++) //枚举当前位置可以为几
  14.     {
  15.         if(!vis[i]) //没有使用过 当前位置可以为i
  16.         {
  17.             vis[i]=1;  //标记并设置当前位置
  18.             res[pos]=i;
  19.             printf("vis[%d]=1 pos:%d=%d
",i,pos,i);
  20.             dfs(pos+1);
  21.             printf("vis[%d]=0
",i);
  22.             vis[i]=0;  //回溯
  23.         }
  24.     }
  25. }

这个递归就稍稍复杂一点了，因为一个递归体会产生几次调用时不知道的，为了让递归调用和返回清晰可见，我在递归调用前和递归调用返回后都加了一些输出，也给循环版本增加了一点难度。

产生了两个新问题：

（1）调用次数位置，不好划分状态。

解决：可以根据当前循环变量i的值设置状态state，因为根据i可以知道要进入的是哪个dfs，其实向下递归的状态可以看做一个状态的，可以统一化处理。

（2）状态返回之后的事情怎么处理？

状态的返回该方法的处理是取栈顶状态，这样就失去了返回的那个过程，返回之后的事情就不好处理了。我采用的方法是将返回之后的事情当做本层下一次递归调用之前的事情，每个状态需要增加一个变量pre记录本层上一次是调用的state是多少。

代码：

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <cstring>
  4. #include <stack>
  5. #define maxn 15
  6. typedef long long ll;
  7. using namespace std;
  8. #define FLAG 1
  9. //如果不想看见递归时的输出 将1改为0
  10.  
  11. int n;
  12. int res[maxn];    //答案数组
  13. bool vis[maxn];   //标记数组
  14.  
  15. struct record
  16. {
  17.     int pos,state,pre;
  18.     record(int pos=0,int state=0,int pre=0):pos(pos),state(state),pre(pre){}
  19.     void show()
  20.     {
  21.         printf("pos:%d state:%d pre:%d ",pos,state,pre);
  22.     }
  23. };
  24. void show(stack<record> my)
  25. {
  26.     while(!my.empty())
  27.     {
  28.         my.top().show();
  29.         my.pop();
  30.     }
  31.     puts("");
  32. }
  33. void debug(record cur,stack<record> s) //调试函数
  34. {
  35.     int i;
  36.     getchar();
  37.     printf("cur:  ");
  38.     cur.show(); puts("");
  39.     show(s);
  40.     for(i=1;i<=n;i++)
  41.     {
  42.         printf("i:%d vis:%d  ",i,vis[i]);
  43.     }
  44.     puts("");
  45.     for(i=1;i<=n;i++)
  46.     {
  47.         printf("i:%d res:%d  ",i,res[i]);
  48.     }
  49.     puts("");
  50. }
  51. void solve()  //循环版本
  52. {
  53.     int i;
  54.     memset(vis,0,sizeof(vis));
  55.     stack<record> s;
  56.     record cur(1,1,0),now;
  57.     while(1)
  58.     {
  59.         //debug(cur,s);
  60.         if(cur.pos>n) // 当前位置大于n找到一组答案 输出并返回上一层
  61.         {
  62.             for(i=1;i<=n;i++)
  63.             {
  64.                 printf("%d ",res[i]);
  65.             }
  66.             puts("");
  67.             if(s.empty()) break; // 栈内没有节点退出
  68.             cur=s.top();
  69.             s.pop();
  70.         }
  71.         else
  72.         {
  73.             if(cur.state<=n) //state1~n的情况
  74.             {
  75.                 for(i=cur.state+1;i<=n;i++)  // 找这一层下次进哪个dfs
  76.                 {
  77.                     if(!vis[i]) break;
  78.                 }
  79.                 if(i<=n) // 本层还要递归 向下递归 保存本层下一次递归
  80.                 {
  81.                     now=cur;  now.state=i;  now.pre=cur.state;
  82.                     vis[cur.pre]=0;  // 将本层的上次递归的vis清0
  83.                     #if FLAG
  84.                         if(cur.pre) printf("vis[%d]=0
",cur.pre);
  85.                         printf("vis[%d]=1 pos:%d=%d
",cur.state,cur.pos,cur.state);
  86.                     #endif
  87.                     vis[cur.state]=1;  // 标记并记录答案
  88.                     res[cur.pos]=cur.state;
  89.                     s.push(now);  // 本层下一次递归入栈
  90.                     cur.pos++;    // cur更新为下一层状态
  91.                     cur.pre=0;
  92.                     for(i=1;i<=n;i++) // 找下一层从哪个dfs开始
  93.                     {
  94.                         if(!vis[i]) break;
  95.                     }
  96.                     cur.state=i;
  97.                 }
  98.                 else  // 该递归是本层最后一次递归 向下递归完后本层结束 返回上层
  99.                 {
  100.                     now=cur;  now.state=n+1;  now.pre=cur.state;
  101.                     vis[cur.pre]=0;  // 将本层的上次递归的vis清0
  102.                     #if FLAG
  103.                     if(cur.pre) printf("vis[%d]=0
",cur.pre);
  104.                     printf("vis[%d]=1 pos:%d=%d
",cur.state,cur.pos,cur.state);
  105.                     #endif // FLAG
  106.                     vis[cur.state]=1;
  107.                     res[cur.pos]=cur.state;
  108.                     s.push(now);
  109.                     cur.pos++;
  110.                     cur.pre=0;
  111.                     for(i=1;i<=n;i++) // 找下一层从哪个dfs开始
  112.                     {
  113.                         if(!vis[i]) break;
  114.                     }
  115.                     cur.state=i;
  116.                 }
  117.             }
  118.             else
  119.             {
  120.                 #if FLAG
  121.                     printf("vis[%d]=0
",cur.pre);
  122.                 #endif // FLAG
  123.                 if(s.empty()) break; // 栈内没有节点退出
  124.                 vis[cur.pre]=0;
  125.                 cur=s.top();
  126.                 s.pop();
  127.             }
  128.         }
  129.     }
  130. }
  131. int main()
  132. {
  133.     while(~scanf("%d",&n))
  134.     {
  135.         solve(); //循环版本
  136.     }
  137.     return 0;
  138. }
  139. /*
  140. 3
  141. */

ps:代码增加了对应递归版本的中间输出，如果不希望看到，这可以把FLAG置为0.

输入3，运行可以得到如下结果，和递归版本的结果一模一样，递归的调用和返回时做的事情也清晰可见。

  1. vis[1]=1 pos:1=1
  2. vis[2]=1 pos:2=2
  3. vis[3]=1 pos:3=3
  4. 1 2 3
  5. vis[3]=0
  6. vis[2]=0
  7. vis[3]=1 pos:2=3
  8. vis[2]=1 pos:3=2
  9. 1 3 2
  10. vis[2]=0
  11. vis[3]=0
  12. vis[1]=0
  13. vis[2]=1 pos:1=2
  14. vis[1]=1 pos:2=1
  15. vis[3]=1 pos:3=3
  16. 2 1 3
  17. vis[3]=0
  18. vis[1]=0
  19. vis[3]=1 pos:2=3
  20. vis[1]=1 pos:3=1
  21. 2 3 1
  22. vis[1]=0
  23. vis[3]=0
  24. vis[2]=0
  25. vis[3]=1 pos:1=3
  26. vis[1]=1 pos:2=1
  27. vis[2]=1 pos:3=2
  28. 3 1 2
  29. vis[2]=0
  30. vis[1]=0
  31. vis[2]=1 pos:2=2
  32. vis[1]=1 pos:3=1
  33. 3 2 1
  34. vis[1]=0
  35. vis[2]=0
  36. vis[3]=0

思路来源于：http://blog.csdn.net/biran007/article/details/4156351


【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/jpfss/p/10820475.html