递归写法,只要理解思想,几行代码。可是非递归写法却很不容易。这里特地总结下,透彻解析它们的非递归写法。其中,中序遍历的非递归写法最简单,后序遍历最难。我们的讨论基础是这样的:
1
2
3
4
5
6
7
|
//Binary
Tree Node typedef
struct node { int data; struct
node* lchild; //左孩子 struct
node* rchild; //右孩子 }BTNode; |
首先,有一点是明确的:非递归写法一定会用到栈,这个应该不用太多的解释。我们先看中序遍历:
中序遍历
分析
中序遍历的递归定义:先左子树,后根节点,再右子树。如何写非递归代码呢?一句话:让代码跟着思维走。我们的思维是什么?思维就是中序遍历的路径。假设,你面前有一棵二叉树,现要求你写出它的中序遍历序列。如果你对中序遍历理解透彻的话,你肯定先找到左子树的最下边的节点。那么下面的代码就是理所当然的:
中序代码段(i)
1
2
3
4
5
6
7
8
|
BTNode*
p = root; //p指向树根 stack<btnode*>
s; //STL中的栈 //一直遍历到左子树最下边,边遍历边保存根节点到栈中 while (p) { s.push(p); p
= p->lchild; }</btnode*> |
保存一路走过的根节点的理由是:中序遍历的需要,遍历完左子树后,需要借助根节点进入右子树。代码走到这里,指针p为空,此时无非两种情况:
说明:
上图中只给出了必要的节点和边,其它的边和节点与讨论无关,不必画出。你可能认为图a中最近保存节点算不得是根节点。如果你看过树、二叉树基础,使用扩充二叉树的概念,就可以解释。总之,不用纠结这个没有意义问题。
整个二叉树只有一个根节点的情况可以划到图a。 仔细想想,二叉树的左子树,最下边是不是上图两种情况?不管怎样,此时都要出栈,并访问该节点。这个节点就是中序序列的第一个节点。根据我们的思维,代码应该是这样:
1
2
3
|
p
= s.top(); s.pop(); cout
<< p->data; |
我们的思维接着走,两图情形不同得区别对待: 1.图a中访问的是一个左孩子,按中序遍历顺序,接下来应访问它的根节点。也就是图a中的另一个节点,高兴的是它已被保存在栈中。我们只需这样的代码和上一步一样的代码:
1
2
3
|
p
= s.top(); s.pop(); cout
<< p->data; |
2.再看图b,由于没有左孩子,根节点就是中序序列中第一个,然后直接是进入右子树:p=p->rchild;在右子树中,又会新一轮的代码段(i)、代码段(ii)……直到栈空且p空。 思维到这里,似乎很不清晰,真的要区分吗?根据图a接下来的代码段(ii)这样的:
1
2
3
4
5
6
7
|
p
= s.top(); s.pop(); cout
<< p->data; p
= s.top(); s.pop(); cout
<< p->data; p
= p->rchild; |
根据图b,代码段(ii)又是这样的:
1
2
3
4
|
p
= s.top(); s.pop(); cout
<< p->data; p
= p->rchild; |
我们可小结下:遍历过程是个循环,并且按代码段(i)、代码段(ii)构成一次循环体,循环直到栈空且p空为止。 不同的处理方法很让人抓狂,可统一处理吗?真的是可以的!回顾扩充二叉树,是不是每个节点都可以看成是根节点呢?那么,代码只需统一写成图b的这种形式。也就是说代码段(ii)统一是这样的:
中序代码段(ii)
1
2
3
4
|
p
= s.top(); s.pop(); cout
<< p->data; p
= p->rchild; |
口说无凭,得经的过理论检验。 图a的代码段(ii)也可写成图b的理由是:由于是叶子节点,p=-=p->rchild;之后p肯定为空。为空,还需经过新一轮的代码段(i)吗?显然不需。(因为不满足循环条件)那就直接进入代码段(ii)。看!最后还是一样的吧。还是连续出栈两次。看到这里,要仔细想想哦!相信你一定会明白的。
这时写出遍历循环体就不难了:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
BTNode*
p = root; stack<btnode*>
s; while (!s.empty()
|| p) { //代码段(i)一直遍历到左子树最下边,边遍历边保存根节点到栈中 while (p) { s.push(p); p
= p->lchild; } //代码段(ii)当p为空时,说明已经到达左子树最下边,这时需要出栈了 if (!s.empty()) { p
= s.top(); s.pop(); cout
<< setw( 4 )
<< p->data; //进入右子树,开始新的一轮左子树遍历(这是递归的自我实现) p
= p->rchild; } }</btnode*> |
仔细想想,上述代码是不是根据我们的思维走向而写出来的呢?再加上边界条件的检测,中序遍历非递归形式的完整代码是这样的:
中序遍历代码一
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
//中序遍历 void InOrderWithoutRecursion1(BTNode*
root) { //空树 if (root
== NULL) return ; //树非空 BTNode*
p = root; stack<btnode*>
s; while (!s.empty()
|| p) { //一直遍历到左子树最下边,边遍历边保存根节点到栈中 while (p) { s.push(p); p
= p->lchild; } //当p为空时,说明已经到达左子树最下边,这时需要出栈了 if (!s.empty()) { p
= s.top(); s.pop(); cout
<< setw( 4 )
<< p->data; //进入右子树,开始新的一轮左子树遍历(这是递归的自我实现) p
= p->rchild; } } }</btnode*> |
恭喜你,你已经完成了中序遍历非递归形式的代码了。回顾一下难吗? 接下来的这份代码,本质上是一样的,相信不用我解释,你也能看懂的。
中序遍历代码二
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
//中序遍历 void InOrderWithoutRecursion2(BTNode*
root) { //空树 if (root
== NULL) return ; //树非空 BTNode*
p = root; stack<btnode*>
s; while (!s.empty()
|| p) { if (p) { s.push(p); p
= p->lchild; } else { p
= s.top(); s.pop(); cout
<< setw( 4 )
<< p->data; p
= p->rchild; } } }</btnode*> |
前序遍历
分析
前序遍历的递归定义:先根节点,后左子树,再右子树。有了中序遍历的基础,不用我再像中序遍历那样引导了吧。 首先,我们遍历左子树,边遍历边打印,并把根节点存入栈中,以后需借助这些节点进入右子树开启新一轮的循环。还得重复一句:所有的节点都可看做是根节点。根据思维走向,写出代码段(i):前序代码段(i)
1
2
3
4
5
6
7
|
//边遍历边打印,并存入栈中,以后需要借助这些根节点(不要怀疑这种说法哦)进入右子树 while (p) { cout
<< setw( 4 )
<< p->data; s.push(p); p
= p->lchild; } |
接下来就是:出栈,根据栈顶节点进入右子树。
前序代码段(ii)
1
2
3
4
5
6
7
|
//当p为空时,说明根和左子树都遍历完了,该进入右子树了 if (!s.empty()) { p
= s.top(); s.pop(); p
= p->rchild; } |
同样地,代码段(i)(ii)构成了一次完整的循环体。至此,不难写出完整的前序遍历的非递归写法。
前序遍历代码一
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
void PreOrderWithoutRecursion1(BTNode*
root) { if (root
== NULL) return ; BTNode*
p = root; stack<btnode*>
s; while (!s.empty()
|| p) { //边遍历边打印,并存入栈中,以后需要借助这些根节点(不要怀疑这种说法哦)进入右子树 while (p) { cout
<< setw( 4 )
<< p->data; s.push(p); p
= p->lchild; } //当p为空时,说明根和左子树都遍历完了,该进入右子树了 if (!s.empty()) { p
= s.top(); s.pop(); p
= p->rchild; } } cout
<< endl; }</btnode*> |
下面给出,本质是一样的另一段代码:
前序遍历代码二
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
//前序遍历 void PreOrderWithoutRecursion2(BTNode*
root) { if (root
== NULL) return ; BTNode*
p = root; stack<btnode*>
s; while (!s.empty()
|| p) { if (p) { cout
<< setw( 4 )
<< p->data; s.push(p); p
= p->lchild; } else { p
= s.top(); s.pop(); p
= p->rchild; } } cout
<< endl; }</btnode*> |
在二叉树中使用的是这样的写法,略有差别,本质上也是一样的:
前序遍历代码三
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
void PreOrderWithoutRecursion3(BTNode*
root) { if (root
== NULL) return ; stack<btnode*>
s; BTNode*
p = root; s.push(root); while (!s.empty())
//循环结束条件与前两种不一样 { //这句表明p在循环中总是非空的 cout
<< setw( 4 )
<< p->data; /* 栈的特点:先进后出 先被访问的根节点的右子树后被访问 */ if (p->rchild) s.push(p->rchild); if (p->lchild) p
= p->lchild; else { //左子树访问完了,访问右子树 p
= s.top(); s.pop(); } } cout
<< endl; }</btnode*> |
最后进入最难的后序遍历:
后序遍历
分析
后序遍历递归定义:先左子树,后右子树,再根节点。后序遍历的难点在于:需要判断上次访问的节点是位于左子树,还是右子树。若是位于左子树,则需跳过根节点,先进入右子树,再回头访问根节点;若是位于右子树,则直接访问根节点。直接看代码,代码中有详细的注释。后序遍历代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
//后序遍历 void PostOrderWithoutRecursion(BTNode*
root) { if (root
== NULL) return ; stack<btnode*>
s; //pCur:当前访问节点,pLastVisit:上次访问节点 BTNode*
pCur, *pLastVisit; //pCur
= root; pCur
= root; pLastVisit
= NULL; //先把pCur移动到左子树最下边 while (pCur) { s.push(pCur); pCur
= pCur->lchild; } while (!s.empty()) { //走到这里,pCur都是空,并已经遍历到左子树底端(看成扩充二叉树,则空,亦是某棵树的左孩子) pCur
= s.top(); s.pop(); //一个根节点被访问的前提是:无右子树或右子树已被访问过 if (pCur->rchild
== NULL || pCur->rchild == pLastVisit) { cout
<< setw( 4 )
<< pCur->data; //修改最近被访问的节点 pLastVisit
= pCur; } /*这里的else语句可换成带条件的else
if: else
if (pCur->lchild == pLastVisit)//若左子树刚被访问过,则需先进入右子树(根节点需再次入栈) 因为:上面的条件没通过就一定是下面的条件满足。仔细想想! */ else { //根节点再次入栈 s.push(pCur); //进入右子树,且可肯定右子树一定不为空 pCur
= pCur->rchild; while (pCur) { s.push(pCur); pCur
= pCur->lchild; } } } cout
<< endl; }</btnode*> |
总结
思维和代码之间总是有巨大的鸿沟。通常是思维正确,清楚,但却不易写出正确的代码。要想越过这鸿沟,只有多尝试、多借鉴,别无它法。转载请注明出处,本文地址:http://blog.csdn.net/zhangxiangdavaid/article/details/37115355
专栏目录:数据结构与算法目录