二叉树遍历(前序、中序、后序)的递归及非递归实现(小结)

先写点最基本的知识

前序遍历： 
    1.访问根节点 
    2.前序遍历左子树 
    3.前序遍历右子树 
中序遍历： 
    1.中序遍历左子树 
    2.访问根节点 
    3.中序遍历右子树 
后序遍历： 
    1.后序遍历左子树 
    2.后序遍历右子树 
    3.访问根节点

递归实现是很容易地，可以参考《算法导论》上的写法

//遍历
//前序、中序、后序遍历
PREVORDER-TREE-WALK(x)
  if x != NIL
     then print key[x]
          PREVORDER-TREE-WALK(left[x])          
          PREVORDER-TREE-WALK(right[x])
//中序
INORDER-TREE-WALK(x)
  if x != NIL
     then INORDER-TREE-WALK(left[x])
          print key[x]
          INORDER-TREE-WALK(right[x])
//后序
POST-TREE-WALK(x)
  if x != NIL 
     then POST-TREE-WALK(left[x])
          POST-TREE-WALK(right[x])
          print key[x]

但看到这篇博文(程序员基本功之遍历二叉树)中的写法，感觉很舒服，也拿过来

def VisitTree_Recursive(root, order):
  if root:
    if order == 'NLR': print(root.data)
    VisitTree_Recursive(root.left, order)
    if order == 'LNR': print(root.data)
    VisitTree_Recursive(root.right, order)
    if order == 'LRN': print(root.data)

上面都是铺垫，递归写法很简单，面试中也不会被问到，会拿来做问题的是非递归写法。感觉(程序员基本功之遍历二叉树)这篇博文对思路的分析非常清楚，也拿过来

非递归的前序、中序遍历

如果不用递归呢？实际上我们要做的就是自己维护一个栈（数据结构）来保存需要但尚未来得及处理的数据。

前序和中序都是非常简单的，当遇到一个非空的根结点时，打印其数据（如果是前序遍历），并将其压栈，然后递归地（这里用循环来模拟递归）处理其左子结点；当没有左子结点时，从栈中弹出之前遇到的某个根结点（它没有做子结点，或者左子结点已经处理完毕，需要再处理右子结点），打印数据（如果是中序遍历），然后继续处理右子结点。同样地，把两种遍历方式写在一起以便比较。

def VisitTree(root, order):
  s = []
  while root or s:
    if root:
      if order == 'NLR': print(root.data)
      s.append(root)
      root = root.left
    else:
      root = s.pop()
      if order == 'LNR': print(root.data)
      root = root.right

博主的python代码果然是清晰易懂，但看到的另外一篇文章(二叉树的非递归前序、中序以及后序遍历C++模版类实现)给出了实现代码，感觉更爽，代码拿过来。

这是基于模板实现的Stack类

#include <iostream>

using namespace std;

//Author: 过往记忆
//Blog: www.wypblog.com
//Email: wyphao.2007@163.com
///////////////////////////////////////////////////////////////////////
//stack 
template <class T>
class Stack{
public:
    Stack(int size = 50);
    ~Stack();
    void push(T* data);
    T* pop();
    bool isEmpty();
    T* peek();
private:
    int size;
    int top;
    bool isFull();
    T **data;
};

template <class T>
Stack<T>::Stack(int size){
    if(size <= 0){
        cout << "分配的内存太小了" << endl; 
    }
    
    data = new T*[size];
    top = -1;
    this->size = size; 
}

template <class T>
Stack<T>::~Stack(){
    delete []data;
}

template <class T>
void Stack<T>::push(T* data){
    ++top;
    if(isFull()){
        cout << "貌似栈满了耶" << endl;
        exit(1); 
    } 
    this->data[top] = data; 
} 

template <class T>
T* Stack<T>::pop(){ 
    if(isEmpty()){
        cout << "栈为空，不可以再出元素了!" << endl;
        exit(1); 
    }
    
    return data[top--]; 
}

template <class T>
T* Stack<T>::peek(){
    if(isEmpty()){
        cout << "栈为空" << endl;
        exit(1); 
    }
    
    return data[top];
}

template <class T>
bool Stack<T>::isFull(){
    if(top == size){
        return true; 
    } 
    
    return false; 
} 

template <class T>
bool Stack<T>::isEmpty(){
    if(top < 0){
        return true; 
    } 
    
    return false; 
} 

下面是使用此Stack实现的非递归版本遍历

template <class T> 
class BTree{
public:
    BTree *left;
    BTree *right;
    T data; 
    
    BTree() : left(NULL), right(NULL), data(NULL){};
    ~BTree(){}; 
}; 

///////////////////////////////////////////////////////////////////////
template <class T> 
void PreOrder(BTree<T> *root){
    if(root != NULL){
        Stack<BTree<T> > stack ;
        BTree<T> *ptr = root;
        BTree<T> *temp; 
        stack.push(ptr);
        while(!stack.isEmpty())    {
            temp =  stack.pop(); 
            cout << temp->data << " ";
            if(temp->right != NULL){
                stack.push(temp->right);
            }
            
            if(temp->left != NULL){
                stack.push(temp->left);
            }
        }
        cout << endl; 
    } 
} 

///////////////////////////////////////////////////////////////////////
template <class T>
void InOrder(BTree<T> *root){
    if(root != NULL){
        Stack<BTree<T> > stack ;
        BTree<T> *ptr = root;
        while(!stack.isEmpty() || ptr != NULL){
            while(ptr != NULL){
                stack.push(ptr);
                ptr = ptr->left;
            }
            
            if(!stack.isEmpty()){
                ptr = stack.pop();
                cout << ptr->data << " ";
                ptr = ptr->right;
            }
            
        }
        cout << endl; 
    }
}

///////////////////////////////////////////////////////////////////////
template <class T>
void PostOrder(BTree<T> *root){
    if(root != NULL){
        Stack<BTree<T> > stack;
        BTree<T> *ptr = root;
        BTree<T> *temp;
        bool flags;
        
        do{
            while(ptr != NULL){
                stack.push(ptr);
                ptr = ptr->left;
            }
            
            temp = NULL;
            flags = true;
            
            while(flags && !stack.isEmpty()){
                ptr = stack.peek();
                if(ptr->right == temp){
                    cout << ptr->data << " ";
                    stack.pop();
                    temp = ptr;
                }else{
                    ptr = ptr->right;
                    flags = false;
                }
            }
        }while(!stack.isEmpty());
        cout << endl;        
    }
}

再次引用(程序员基本功之遍历二叉树)中分析。

后序遍历要稍微复杂一点点，在前序和中序遍历的程序中，当我们准备进入根结点的右子树时，根结点就被扔出栈外了。但在后序遍历时，我们仍需保留它，直到右子树处理完毕。实际上当左子树遍历完成、或者右子树遍历完成时，我们都会在栈里看到根结点，为了区分这两种状态，添加一个临时变量记录前一次访问的结点，如果前一个结点是根结点的右子树，就说明左右子树全都遍历完成了。这也是以上PostOrder采用的方式。

---

看到程序员基本功之遍历二叉树中介绍二叉树的层序遍历，搜集一下，以备参考

非递归的时候，层序遍历使用的是队列，而非栈。处理过程非常简明，遇到一个结点，打印信息，然后依次将左、右子结点加入队列等待后续处理。

from collections import deque

def VisitTree_LevelOrder(root):
  if not root: return
  q = deque([root])
  while q:
    root = q.popleft()
    print(root.data)
    if root.left: q.append(root.left)
    if root.right: q.append(root.right)

这篇博文(数据结构（六）——二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现)给出了层序遍历的实现代码，如下

首先是自定义队列

#define MAX 1000  
  
typedef struct seqqueue{  
    bintree data[MAX];  
    int front;  
    int rear;  
}seqqueue;  
  
  
void enter(seqqueue *q,bintree t){  
    if(q->rear == MAX){  
        printf("the queue is full!
");  
    }else{  
        q->data[q->rear] = t;  
        q->rear++;  
    }  
}  
  
bintree del(seqqueue *q){  
    if(q->front == q->rear){  
        return NULL;  
    }else{  
        q->front++;  
        return q->data[q->front-1];  
    }  
}  

然后是层序遍历，和上面提到的层序遍历一个道理

void level_tree(bintree t){  
    seqqueue q;  
    bintree temp;  
    q.front = q.rear = 0;  
    if(!t){  
        printf("the tree is empty
");  
        return ;  
    }  
    enter(&q,t);  
    while(q.front != q.rear){  
        t=del(&q);  
        printf("%c ",t->data);  
        if(t->lchild){  
            enter(&q,t->lchild);  
        }  
        if(t->rchild){  
            enter(&q,t->rchild);  
        }  
    }  
}  

---

还提到二叉树的其他常用算法，一并拿过来

统计结点个数

int count_tree(bintree t){  
    if(t){  
        return (count_tree(t->lchild)+count_tree(t->rchild)+1);  
    }  
    return 0;  
}

比较两个树是否相同

int is_equal(bintree t1,bintree t2){  
    if(!t1 && !t2){      //都为空就相等  
        return 1;  
    }  
    if(t1 && t2 && t1->data == t2->data){      //有一个为空或数据不同就不判断了  
        if(is_equal(t1->lchild,t2->lchild))  
            if(is_equal(t1->rchild,t2->rchild)){  
                return 1;  
            }  
    }  
    return 0;  
}  

求二叉树的深度

int hight_tree(bintree t){  
    int h,left,right;  
    if(!t){  
        return 0;  
    }  
    left = hight_tree(t->lchild);  
    right = hight_tree(t->rchild);  
    h = (left>right?left:right)+1;  
    return h;  
}

参考博文：

1.程序员基本功之遍历二叉树

2.二叉树的非递归前序、中序以及后序遍历C++模版类实现

3.数据结构（六）——二叉树 前序、中序、后序、层次遍历及非递归实现 查找、统计个数、比较、求深度的递归实现