轉載請注明出處：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.二叉樹遍歷代碼：
-
#include <stdio.h>
-
#include <stdlib.h>
-
#include <stack>
-
#include <algorithm>
-
using
namespace
std;
-
-
struct node
-
{
-
int val;
-
node *le,*ri;
-
};
-
struct record
-
{
-
node* a;
-
int state;
-
record(node* a,
int state):a(a),state(state) {}
-
};
-
-
void non_recursive_inorder(node* root) //循環中序遍歷
-
{
-
stack<record> s;
-
node* cur=root;
//初始化狀態
-
int state=
0;
-
while(
1)
-
{
-
if(!cur)
//如果遇到null結點，返回上一層 對應遞歸中的if(pos==NULL) return ;
-
{
-
if(s.empty())
break;
//如果沒有上一層，退出循環
-
cur=s.top().a;
-
state=s.top().state;
//返回上層狀態
-
s.pop();
-
}
-
else
if(state ==
0)
//state0，執行第一個遞歸inorder(cur->le);
-
{
-
s.push(record(cur,
1));
//保存本層狀態
-
cur=cur->le;
//更新到下層狀態
-
state=
0;
-
}
-
else
if(state ==
1)
//state1，執行print和inorder(cur->ri)
-
{
-
printf(
"%d ",cur->val);
-
s.push(record(cur,
2));
//保存本層狀態
-
cur=cur->ri;
//進入下層狀態
-
state=
0;
-
}
-
else
if(state ==
2)
//state2，函數結束，返回上層狀態
-
{
-
if(s.empty())
break;
//初始結點的退出狀態，遍歷結束
-
cur=s.top().a;
//返回上層狀態
-
state=s.top().state;
-
s.pop();
-
}
-
}
-
putchar(
'\n');
-
}
-
-
void build(node **pos,int val) //建二叉樹
-
{
-
if(*pos==
NULL)
-
{
-
*pos=(node *)
malloc(
sizeof(node));
-
(*pos)->val=val;
-
(*pos)->le=(*pos)->ri=
NULL;
-
return ;
-
}
-
if(val<(*pos)->val) build(&((*pos)->le),val);
-
else
if(val>(*pos)->val) build(&((*pos)->ri),val);
-
}
-
void Del(node *pos) //刪除二叉樹
-
{
-
if(pos==
NULL)
return;
-
Del(pos->le);
-
Del(pos->ri);
-
free(pos);
-
}
-
void visit_mid(node *pos) //遞歸中序遍歷
-
{
-
if(pos==
NULL)
return ;
-
visit_mid(pos->le);
-
printf(
"%d ",pos->val);
-
visit_mid(pos->ri);
-
}
-
int main()
-
{
-
int i,n,x;
-
while(~
scanf(
"%d",&n))
-
{
-
node *root=
NULL;
-
for(i=
1; i<=n; i++)
-
{
-
scanf(
"%d",&x);
-
build(&root,x);
-
}
-
puts(
"遞歸中序遍歷:");
-
visit_mid(root);
-
puts(
"");
-
puts(
"循環中序遍歷:");
-
non_recursive_inorder(root);
-
Del(root);
-
}
-
return
0;
-
}
-
/*
-
9
-
5 2 1 4 3 8 6 7 9
-
*/
可以畫出遞歸的調用和返回的圖，手動模擬代碼運行，看每一步cur和棧里面的狀態時怎樣的，能夠幫助更好的理解這種思想。
若要將中序改成先序和后序，也只用改變代碼中的printf的位置即可，知道每個state要做什么事情就行。
4.快速排序：
快速排序是分治、遞歸經典應用，一般的寫法都是遞歸，因為其代碼簡單易懂，我們不妨也用上述思路來轉化為循環版本，因為遞歸的形式和二叉樹的遍歷基本一致，也只需划分為3種情況即可。
代碼：
-
#include <iostream>
-
#include <cstdio>
-
#include <cstring>
-
#include <stack>
-
#define maxn 1005
-
using
namespace
std;
-
-
int a[maxn];
-
-
struct record
-
{
-
int le,ri,state;
-
record(
int le=
0,
int ri=
0,
int state=
0):le(le),ri(ri),state(state){}
-
};
-
-
int Partition(int le,int ri) //划分
-
{
-
int tmp=a[le],pos=le;
-
while(le<ri)
-
{
-
while(le<ri&&a[ri]>=tmp) ri--;
-
a[pos]=a[ri];
-
pos=ri;
-
while(le<ri&&a[le]<=tmp) le++;
-
a[pos]=a[le];
-
pos=le;
-
}
-
a[pos]=tmp;
-
return pos;
-
}
-
void Qsort(int le,int ri) //遞歸版本
-
{
-
if(le<ri)
-
{
-
int p=Partition(le,ri);
-
Qsort(le,p
-1);
-
Qsort(p+
1,ri);
-
}
-
}
-
void QsortLoop(int n) //循環版本
-
{
-
int i;
-
record cur(1,n,0),now;
-
stack<record>s;
-
while(
1)
-
{
-
//getchar();
-
//printf("%d %d %d\n",cur.le,cur.ri,cur.state);
-
if(cur.le<cur.ri)
-
{
-
if(cur.state==
0)
//划分 向下遞歸 保存本層下次遞歸狀態
-
{
-
int p=Partition(cur.le,cur.ri);
-
now.le=p+
1; now.ri=cur.ri; now.state=
1;
-
s.push(now);
-
cur.ri=p
-1;
-
}
-
else
if(cur.state==
1)
//向下遞歸 保存本層下次遞歸狀態
-
{
-
now=cur; now.state=
2;
-
s.push(now);
-
cur.state=
0;
-
}
-
else
-
{
-
if(s.empty())
break ;
//棧內沒有節點退出
-
cur=s.top();
-
s.pop();
-
}
-
}
-
else
//遞歸返回
-
{
-
if(s.empty())
break ;
//棧內沒有節點退出 不加這句可以試一試2 1 2
-
cur=s.top();
-
s.pop();
-
}
-
}
-
}
-
int main()
-
{
-
int i,n;
-
while(~
scanf(
"%d",&n))
-
{
-
for(i=
1;i<=n;i++)
scanf(
"%d",&a[i]);
-
//Qsort(1,n);
-
QsortLoop(n);
-
for(i=
1;i<=n;i++)
-
{
-
printf(
"%d ",a[i]);
-
}
-
puts(
"");
-
}
-
return
0;
-
}
-
/*
-
5
-
1 2 3 4 5
-
7
-
5 10 8 6 3 20 2
-
6
-
64 5 3 45 6 78
-
*/
5.輸出1~n的全排列。
首先來看一下循環的版本，初始化vis為0，調用dfs(n)即可得到結果：
-
int res[maxn];
//答案數組
-
bool vis[maxn];
//標記數組
-
void dfs(int pos) //當前進行到pos位置
-
{
-
if(pos==n+
1)
//為n+1則得到了一組答案 輸出
-
{
-
for(
int i=
1; i<=n; i++)
-
{
-
printf(
"%d ",res[i]);
-
}
-
puts(
"");
-
}
-
for(
int i=
1; i<=n; i++)
//枚舉當前位置可以為幾
-
{
-
if(!vis[i])
//沒有使用過 當前位置可以為i
-
{
-
vis[i]=
1;
//標記並設置當前位置
-
res[pos]=i;
-
printf(
"vis[%d]=1 pos:%d=%d\n",i,pos,i);
-
dfs(pos+
1);
-
printf(
"vis[%d]=0\n",i);
-
vis[i]=
0;
//回溯
-
}
-
}
-
}
這個遞歸就稍稍復雜一點了，因為一個遞歸體會產生幾次調用時不知道的，為了讓遞歸調用和返回清晰可見，我在遞歸調用前和遞歸調用返回后都加了一些輸出，也給循環版本增加了一點難度。
產生了兩個新問題：
（1）調用次數位置，不好划分狀態。
解決：可以根據當前循環變量i的值設置狀態state，因為根據i可以知道要進入的是哪個dfs，其實向下遞歸的狀態可以看做一個狀態的，可以統一化處理。
（2）狀態返回之后的事情怎么處理？
狀態的返回該方法的處理是取棧頂狀態，這樣就失去了返回的那個過程，返回之后的事情就不好處理了。我采用的方法是將返回之后的事情當做本層下一次遞歸調用之前的事情，每個狀態需要增加一個變量pre記錄本層上一次是調用的state是多少。
代碼：
-
#include <iostream>
-
#include <cstdio>
-
#include <cstring>
-
#include <stack>
-
#define maxn 15
-
typedef
long
long ll;
-
using
namespace
std;
-
#define FLAG 1
-
//如果不想看見遞歸時的輸出 將1改為0
-
-
int n;
-
int res[maxn];
//答案數組
-
bool vis[maxn];
//標記數組
-
-
struct record
-
{
-
int pos,state,pre;
-
record(
int pos=
0,
int state=
0,
int pre=
0):pos(pos),state(state),pre(pre){}
-
void show()
-
{
-
printf(
"pos:%d state:%d pre:%d ",pos,state,pre);
-
}
-
};
-
void show(stack<record> my)
-
{
-
while(!my.empty())
-
{
-
my.top().show();
-
my.pop();
-
}
-
puts(
"");
-
}
-
void debug(record cur,stack<record> s) //調試函數
-
{
-
int i;
-
getchar();
-
printf(
"cur: ");
-
cur.show();
puts(
"");
-
show(s);
-
for(i=
1;i<=n;i++)
-
{
-
printf(
"i:%d vis:%d ",i,vis[i]);
-
}
-
puts(
"");
-
for(i=
1;i<=n;i++)
-
{
-
printf(
"i:%d res:%d ",i,res[i]);
-
}
-
puts(
"");
-
}
-
void solve() //循環版本
-
{
-
int i;
-
memset(vis,
0,
sizeof(vis));
-
stack<record> s;
-
record cur(1,1,0),now;
-
while(
1)
-
{
-
//debug(cur,s);
-
if(cur.pos>n)
// 當前位置大於n找到一組答案 輸出並返回上一層
-
{
-
for(i=
1;i<=n;i++)
-
{
-
printf(
"%d ",res[i]);
-
}
-
puts(
"");
-
if(s.empty())
break;
// 棧內沒有節點退出
-
cur=s.top();
-
s.pop();
-
}
-
else
-
{
-
if(cur.state<=n)
//state1~n的情況
-
{
-
for(i=cur.state+
1;i<=n;i++)
// 找這一層下次進哪個dfs
-
{
-
if(!vis[i])
break;
-
}
-
if(i<=n)
// 本層還要遞歸 向下遞歸 保存本層下一次遞歸
-
{
-
now=cur; now.state=i; now.pre=cur.state;
-
vis[cur.pre]=
0;
// 將本層的上次遞歸的vis清0
-
#if FLAG
-
if(cur.pre)
printf(
"vis[%d]=0\n",cur.pre);
-
printf(
"vis[%d]=1 pos:%d=%d\n",cur.state,cur.pos,cur.state);
-
#endif
-
vis[cur.state]=
1;
// 標記並記錄答案
-
res[cur.pos]=cur.state;
-
s.push(now);
// 本層下一次遞歸入棧
-
cur.pos++;
// cur更新為下一層狀態
-
cur.pre=
0;
-
for(i=
1;i<=n;i++)
// 找下一層從哪個dfs開始
-
{
-
if(!vis[i])
break;
-
}
-
cur.state=i;
-
}
-
else
// 該遞歸是本層最后一次遞歸 向下遞歸完后本層結束 返回上層
-
{
-
now=cur; now.state=n+
1; now.pre=cur.state;
-
vis[cur.pre]=
0;
// 將本層的上次遞歸的vis清0
-
#if FLAG
-
if(cur.pre)
printf(
"vis[%d]=0\n",cur.pre);
-
printf(
"vis[%d]=1 pos:%d=%d\n",cur.state,cur.pos,cur.state);
-
#endif // FLAG
-
vis[cur.state]=
1;
-
res[cur.pos]=cur.state;
-
s.push(now);
-
cur.pos++;
-
cur.pre=
0;
-
for(i=
1;i<=n;i++)
// 找下一層從哪個dfs開始
-
{
-
if(!vis[i])
break;
-
}
-
cur.state=i;
-
}
-
}
-
else
-
{
-
#
if FLAG
-
printf(
"vis[%d]=0\n",cur.pre);
-
#endif // FLAG
-
if(s.empty())
break;
// 棧內沒有節點退出
-
vis[cur.pre]=
0;
-
cur=s.top();
-
s.pop();
-
}
-
}
-
}
-
}
-
int main()
-
{
-
while(~
scanf(
"%d",&n))
-
{
-
solve();
//循環版本
-
}
-
return
0;
-
}
-
/*
-
3
-
*/
ps:代碼增加了對應遞歸版本的中間輸出，如果不希望看到，這可以把FLAG置為0.
輸入3，運行可以得到如下結果，和遞歸版本的結果一模一樣，遞歸的調用和返回時做的事情也清晰可見。
-
vis[1]=1 pos:1=1
-
vis[2]=1 pos:2=2
-
vis[3]=1 pos:3=3
-
1 2 3
-
vis[3]=0
-
vis[2]=0
-
vis[3]=1 pos:2=3
-
vis[2]=1 pos:3=2
-
1 3 2
-
vis[2]=0
-
vis[3]=0
-
vis[1]=0
-
vis[2]=1 pos:1=2
-
vis[1]=1 pos:2=1
-
vis[3]=1 pos:3=3
-
2 1 3
-
vis[3]=0
-
vis[1]=0
-
vis[3]=1 pos:2=3
-
vis[1]=1 pos:3=1
-
2 3 1
-
vis[1]=0
-
vis[3]=0
-
vis[2]=0
-
vis[3]=1 pos:1=3
-
vis[1]=1 pos:2=1
-
vis[2]=1 pos:3=2
-
3 1 2
-
vis[2]=0
-
vis[1]=0
-
vis[2]=1 pos:2=2
-
vis[1]=1 pos:3=1
-
3 2 1
-
vis[1]=0
-
vis[2]=0
-
vis[3]=0
思路來源於： http://blog.csdn.net/biran007/article/details/4156351