程序博客网 > 手机金山数据恢复大师

递归转换循环

来源：互联网 发布：手机金山数据恢复大师 编辑：程序博客网 时间：2024/06/06 01:25

转载请注明出处：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.二叉树遍历代码：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  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('\n');  
  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种情况即可。

代码：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  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\n",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)即可得到结果：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  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\n",i,pos,i);  
  20.             dfs(pos+1);  
  21.             printf("vis[%d]=0\n",i);  
  22.             vis[i]=0;  //回溯  
  23.         }  
  24.     }  
  25. }  

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

产生了两个新问题：

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

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

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

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

代码：

[cpp] view plain copy
 在CODE上查看代码片派生到我的代码片
  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\n",cur.pre);  
  85.                         printf("vis[%d]=1 pos:%d=%d\n",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\n",cur.pre);  
  104.                     printf("vis[%d]=1 pos:%d=%d\n",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\n",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，运行可以得到如下结果，和递归版本的结果一模一样，递归的调用和返回时做的事情也清晰可见。

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  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
0 0
手机金山数据恢复大师 手机金山数据恢复大师
原创粉丝点击
热门IT博客
丝绸之路网络论坛网址丝绸之路网络论坛网址
怎么创建三级域名怎么创建三级域名
淘宝直播需要缴费吗
淘宝福袋衣服的来源
如何制作模拟考试软件
dnd 知乎
中国十大域名注册商
pda扫描枪与数据库
mac os取消密码验证
mac自带p图软件
ove mac
linux里sleep函数
软件国产化证书
淘宝店铺包邮图片
js递归算法经典实例
平安银行淘宝卡年费
91porn邀请码 淘宝
vivox7知乎
linux文件系统 挂载
淘口令怎么在淘宝打开
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 开瑞优劲双排加长版 开瑞优劲论坛 开瑞优劲双排优缺点 开瑞优劲发动机多少钱 奇瑞优劲 五菱荣光小卡单排1.5 五菱荣光小卡双排1.2 五菱荣光小卡双排加长 五菱荣光小卡双排1.5 长安神骐小卡 长安神骐小卡柴油版 优势 个人优势 比较优势 联动优势 优势理论 顶端优势 光大优势 优势英文 自身优势 竞争优势 我的优势 5g优势 优势怎么写 竞选优势 华夏优势 优势英语 交银优势行业混合 个人优势怎么写 华夏优势增长 000021华夏优势增长 光大优势基金净值 华夏优势增长基金净值 华夏优势基金净值 比较优势理论 苏宁扩大优势 杠杆黄金优势 东方红中国优势 杠杆黄金的优势 天津高考优势还大吗 519697交银优势行业

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里