二叉树的递归遍历算法解析

这里我主要讲讲如何理解递归算法.....

人们正常的思维方式是从前顺着往后，而递归算法相反，从后摸着往前。

所以呢，给你一段递归代码，若要在短时间内了解它是如何运行的，则必须转变你的思维方式，下面就讲讲本菜鸟是如何理解的...!敲黑板请注意我要开始我的表演了.....

首先，给出具体的代码：包括二叉树的先序建立，二叉树的先序，中序和后序遍历

#include
using namespace std;
struct BiTree{
	char data;
	BiTree *leftChild;
	BiTree *rightChild;
}; 
void createBiTree(BiTree *&T)  //特别要注意这里的参数是*&T，而不是*T 
{  
    char c;  
    cin >> c;  
    if('#' == c)  
        T = NULL;  
    else  
    {  
        T = new BiTree();  
        T->data = c;  
        createBiTree(T->leftChild);  
        createBiTree(T->rightChild);  
    }  
}  //二叉树的递归建立,按照先序的办法... 
void pre(BiTree *T){
	if(T){
		cout<data<leftChild);
		pre(T->rightChild);
	}
}//先序 
void in(BiTree *T){
	if(T){
		in(T->leftChild);
		cout<data<rightChild); 
	}
}//中序 
void back(BiTree *T){
	if(T){
		back(T->leftChild);
		back(T->rightChild);
		cout<data<

大家看到没，其实这三段遍历代码，结构相似，唯一不同的是输出段cout<data<

下面，我以中序算法为例讲解下这是如何做到递归遍历的.

递归算法层层递归，但是最后总是存在一个条件，当这个条件被满足的时候，就是递归结束的时候...

而在中序算法中，这个条件就是T为空.

抓住这个条件就可以把递归的最底层抓出来.

正顺图：

（节点A）left          ->    （节点B）left       ->     （节点D）left               ->   NULL（敲黑板，抓住了递归的底层1）    

    输出A !                         输出B!                               输出D!

right ! ....                            right!.....                            right!.....

这样子的话，抓住了递归的底层，那我们就可以往回走了

NULL->left->输出D->right....（记为第一步，输出了D）

然后看看right的...具体是什么

（节点D）left

输出D

right     ->NULL（敲黑板，抓住了递归底层2）.

那就可以继续往回走了NULL->right->输出D->left（注意到这是第一步的倒退走，不输出D，继续折回去）

（节点A）left          ->    （节点B）left     

输出A                        输出B

right   ....                   right.....   

那就是要走这一步

left->输出B->right....(记为第二步，输出了B，继续看看具体的right是什么)

（节点B）left

              输出B!

  right->（节点E）left->(NULL)(没错这又是一个递归底层，抓住这个就往回走吧)

                          输出E

                           right......

走这一步left->输出E->right.....（记为第三步，输出了E）

然后我们看看right是什么

right->NULL（没错又可以继续折回去）

right->输出E->left(第三步的倒退，不输出，继续折回去)

（节点A）left          ->    （节点B）left       

输出A                               输出B 

right   ....                            right.....   

right->输出B->left（第二步的倒退，不输出，继续折回去）

（节点A）left         

                 输出A

               right   ....     

left->输出A->right(记为第四步，输出A，再看看具体的right....是什么)

（节点A）left         

               输出A

              right     ->  (节点C)left->NULL(又抓到NULL了，可以折回去）

                                输出C

                                right....

NULL->left->输出C->right.....(记为第五步，输出C，再看看right....是什么)

（节点C）left

输出C

right    ->（节点F）left->NULL（抓到NULL，可以往回折了）

                       输出F

                       right....

NULL->left->输出F->right....（记为第六步，输出F，再看看right是什么）

（节点F）left

输出F

right->NULL(抓到NULL，折回去)

NULL->right->输出F->left(第六步的倒退不输出，继续折回去)

 （节点A）left     

              输出A

               right  ->(节点C)left

                           输出C

                            right

right->输出C->left(第五步的倒退，不输出，继续折回去)

（节点A）left     

                输出A

                right 

right->输出A->left（第四步的倒退，不输出，继续折回去）

啊啊啊啊啊啊啊啊啊啊啊啊啊啊，不知不觉的就走到的最首层，也没有路可以折回去

所以，整个代码运行到这就结束了

结果是

输出DBEACF.....!

好了我的表演到此结束！

但是呢，一般人在接触到递归算法代码的时候，如果都像我一样花时间去画个图啊什么的都太费时间了

但是呢，

记住找到并抓住递归的结束条件并能够准确的判断出啥时候结束递归，再按着一步一步往回退

我觉得对你的快速理解是有一定帮助哒。