二叉树的遍历

一、先定义二叉树的数据结构

typedef struct TreeNode *BinTree;

struct TreeNode
{
ElementType data;
BinTree left;
BinTree right;
};

二、基于DFS的递归遍历
       1. 先序遍历(PreOrder)

void PreOrder(BinTree T)
{
if(!T) return;
Visit(T);
PreOrder(T->left);
PreOrder(T->right);
}

      2. 中序遍历(InOrder)

void InOrder(BinTree T)
{
if(!T) return;
InOrder(T->left);
Visit(T);
InOrder(T->right);
}

      3. 后序遍历(PostOrder)

void PostOrder(BinTree T)
{
if(!T) return;
InOrder(T->left);
InOrder(T->right);
Visit(T);
}

      Summarize: 这三种遍历过程，经过结点的路线是一样的，只是访问各结点的时机不同。

三、利用堆栈实现非递归遍历
       借助堆栈实现实际上就是模拟递归函数调用时的入栈和出栈过程，先序遍历是结点第一次入栈即访问，然后分别对该结点的左右子树遍历；中序遍历是当结点出栈时，表明刚完成对该结点左子树的访问，这时访问该结点。
      1. 先序非递归
          1) 遇到一个结点，访问后入栈，并遍历其左子树；
          2) 当左子树遍历完后，从栈顶弹出一个结点；
          3) 按该结点的右指针遍历其右子树;
          4) 当p为NULL且栈空时，整个遍历过程结束。

void PreOrder(BinTree T)
{
stack<BinTree> S;
BinTree p = T;

while(p || !S.empty())
{
while(p){
Visit(p);
S.push(p);
p = p->left;
}
if(!S.empty()){
p = S.top();
S.pop();
p = p->right;
}
}
}

      2. 中序非递归
          同先序基本一样，不同之处在于访问结点的时机，是在结点出栈后访问。

void InOrder(BinTree T)
{
stack<BinTree> S;
BinTree p = T;

while(p || !S.empty())
{
while(p){
S.push(p);
p = p->left;
}
if(!S.empty()){
p = S.top();
Visit(p);
S.pop();
p = p->right;
}
}
}

      3. 后序非递归
          与前两个非递归的过程不同，后序遍历必须在左右子树均访问后才访问根结点，关键是要确定什么时候右子树遍历结束。一种思路是在某一结点的左子树遍历完后将其再次入栈，等到再次出栈就说明其右子树已经遍历结束，这时候就可以访问该结点了。也就是说，在整个后序非递归过程中，每个结点出入栈两次，第一次出栈说明其左子树遍历完成，第二次出栈说明其右子树也遍历完成，而为了区分是第几次出栈，每个结点需要添加一个变量标记。

void postOrder(BinTree T)
{
if(!T) return;

stack<BinTree> S;
BinTree p = T;
while(p || !S.empty())
{
if(p){
S.push(p);
p = p->left;
}
else{
p = S.top();
S.pop();
p->flag++;
if(p->flag == 2){
Visit(p);
p = NULL;
}
else{
S.push(p);
p = p->right;
}
}
}
}

四、基于BFS的层序遍历
       1. 层序遍历用队列实现，从根节点开始，首先将根节点入队，然后执行循环：结点出队并访问，左右结点入队，直到队列为空，形成按广度优先搜索的遍历方式。
       基本过程：
       1) 根节点入队；
       2) 从队列中出队一个结点；
       3) 访问该结点；
       4) 如果该结点左右子结点非空，依次入队；
       5) 队列为空，遍历结束。

void LevelOrder(BinTree T)
{
if(!T) return;

queue<BinTree> Q;
BinTree p = T;
Q.push(p);
while(!Q.empty())
{
p = Q.front();
Visit(p);
Q.pop();

if(p->left)
Q.push(p->left);
if(p->right)
Q.push(p->right);
}
}

     2. 有意思的是，基于层序遍历的思想也可以实现先序、中序和后序三种遍历。只要将队列改为栈，同时改变结点的的入栈顺序即可。
        1) 先序：入栈顺序为右结点再左结点。

void LevelPreOrder(BinTree T)
{
if(!T) return;
stack<BinTree> S;
BinTree p = T;
S.push(p);
while(!S.empty())
{
p = S.top();
Visit(p);
S.pop();

if(p->right)
S.push(p->right);
if(p->left)
S.push(p->left);
}
}

       2) 中序：为了知道左右子树什么时候遍历结束，结点需要出入栈两次，第一次出栈后在左右结点间再次入栈，第二次出栈时即可访问该结点。
           入栈顺序：右结点->当前结点->左结点

void LevelInOrder(BinTree T)
{
if(!T) return;
stack<BinTree> S;
BinTree p = T;
S.push(p);
while(!S.empty())
{
p = S.top();
p->flag++;
S.pop();
if(p->flag == 2){
Visit(p);
}
else{
if(p->right)
S.push(p->right);
S.push(p);
if(p->left)
S.push(p->left);
}
}
}

        3) 后序：与中序类似，结点第一次出栈后在左右结点之前再次入栈，第二次出栈后访问。入栈顺序：当前结点->右结点->左结点

void LevelPostOrder(BinTree T)
{
if(!T) return;
stack<BinTree> S;
BinTree p = T;
S.push(p);
while(!S.empty())
{
p = S.top();
p->flag++;
S.pop();
if(p->flag == 2){
Visit(p);
}
else{
S.push(p);
if(p->right)
S.push(p->right);
if(p->left)
S.push(p->left);
}
}
}