二叉查找树的遍历总结

要准备面试了，最近才开始看些往年的笔试，面试题，今晚就写一篇最基础的二叉查找树的遍历总结吧。

先序遍历：  先根，再左子树，最后右子树；

中序遍历：  先左子树，再根，最后右子树；

后序遍历：  先左子树， 再右子树，最后根；

以上的每种遍历方式都对应有两种写法：递归与非递归；

仅拿先序遍历的非递归方式来说（其余两种遍历类似）

两者共同点： 对节点的遍历次序一致；

区别：（先序遍历）在非递归调用中，对右子树的遍历在左子树后，先将右子树节点入栈，再将左子树节点入栈，这样在出栈进行遍历的时候起到先遍历左子树，再遍历右子树的效果。 而在递归调用中，先调用左子树的遍历函数，再调用右子树的遍历函数，起到的效果是一致的。

中序遍历的非递归方式：

考虑到先左，再根，后右的顺序，借用栈来实现的时候，应该是：

每次沿左子树的路径走，把路径上的结点依次入栈直到某个结点没有左子，然后该结点出栈，同时将该结点指向其右子，再重复……

后序遍历的非递归方式：

我的做法是对树取反，即左子权值 > 根权值 > 右子权值， 对该反树先序遍历的序列取反即是原来树的后序遍历。我只需要在先序遍历的非递归方式中把左右入栈的顺序改变即可，同时新开一个O(n)的栈来保存要输出的遍历序列。（其他方法我还未想到）

下面是我的代码，在必要的地方都有注释，希望自己能对new，delete，析构函数，构造函数等越来越熟悉。

#include <cstdio>
#include <cstdlib>
#include <stack>
using namespace std;

struct Node{
    int value;
    Node *Left, *Right;
    // Node(){}
    Node(int value_){  /// 构造函数；
        value= value_;
        Left= Right= NULL;
    }

    ~Node(){ /// 析构函数，用于在程序运行结束后释放内存，养成良好的编程习惯；
        if( Left ){
            delete Left;
            Left= NULL;
        }
        if( Right ){
            delete Right;
            Right= NULL;
        }
    }
};

/*----- 开辟新的结点，返回该结点地址 -----*/
/*
Node *NewNode(int value){
    Node *p = new Node;  //Node *p= (Node *)malloc( sizeof( Node ) );
    p->value= value;
    p->Left= p->Right= NULL;
    return p;
}*/


/*----- 插入新的节点， 返回根结点的地址root -----*/
Node *Insert(int value, Node *root){
    if( root==NULL ){
        Node *p= new Node( value ); /// new:1、分配足够内存，2、调用构造函数初始化；
        return p;
    }
    Node *p= root, *fp;
    while( p ){
        fp= p;
        if( p->value > value ) p= p->Left;
        else p= p->Right;
    }
    p= new Node( value );
    if( fp->value > value ) fp->Left= p;
    else fp->Right= p;
    return root;
}

/*
共同点：两者对节点的遍历次序一致

区别：在非递归调用中，对右子树的访问在左子树后面，所以先将右子树节点压栈，
再压左子树节点,这样在出栈进行遍历的时候起到先遍历左子树，再遍历右子树的效果。
在递归调用中，对左右子树调用的先后区别在于是先调用左子树的遍历函数，
再调用右子树的遍历函数，起到的效果是一致的。
*/

/*----- 非递归方式先序遍历 -----*/
void Preorder_Travel_No_Recursion(Node *root){
    if( root == NULL ) return;
    stack<Node *> ss;
    ss.push( root );
    while( !ss.empty() ){
        root= ss.top();    /// .top()： 取栈顶元素；
        ss.pop();       /// .pop():  弹出栈顶元素；
        printf("%d ", root->value);

        if( root->Right ) ss.push( root->Right );   /// 先将右子结点入栈，保证是先序遍历；
        if( root->Left ) ss.push( root->Left );
    }
}


/*----- 递归方式先序遍历 -----*/
void Preorder_Travel(Node *root){
    if( root ){
        printf("%d ", root->value);
        Preorder_Travel( root->Left );
        Preorder_Travel( root->Right );
    }
}


/*----- 非递归方式中序遍历 -----*/
void Inorder_Travel_No_Recursion(Node *root){
    if( root == NULL ) return;
    stack<Node *> ss;
    while( !ss.empty() || root ){  /// 2个结束条件；
        while( root ){
            ss.push( root );
            root= root->Left;
        }
        root= ss.top();
        ss.pop();
        printf("%d ", root->value );
        root= root->Right;
    }
}


/*----- 递归方式中序遍历 -----*/
void Inorder_Travel(Node *root){
    if( root ){
        Inorder_Travel( root->Left );
        printf("%d ", root->value);
        Inorder_Travel( root->Right );
    }
}


/*----- 递归方式后序遍历 -----*/
void Postorder_Travel(Node *root){
    if( root ){
        Postorder_Travel( root->Left );
        Postorder_Travel( root->Right );
        printf("%d ", root->value);
    }
}


/*----- 非递归方式后序遍历 -----*/
void Postorder_Travel_No_Recursion(Node *root){
    if( root == NULL ) return;
    stack<Node *> ss;
    stack<int> out;
    ss.push( root );
    while( !ss.empty() ){
        root= ss.top();
        ss.pop();

        out.push( root->value );
        if( root->Left ) ss.push( root->Left );
        if( root->Right ) ss.push( root->Right );
    }
    while( !out.empty() ){
        printf("%d ", out.top() );
        out.pop();
    }
}

int main(){
    int a[]={5,2,7,1,8,9,3,4,6};
    int n= sizeof(a)/sizeof(*a);
    Node *root= NULL;
    for(int i=0; i<n; ++i){
        root= Insert( a[i], root );
    }

    printf("先序遍历（递归）：  ");
    Preorder_Travel( root );
    puts("");

    printf("先序遍历（非递归）：");
    Preorder_Travel_No_Recursion( root );
    puts("");

    printf("中序遍历（递归）：  ");
    Inorder_Travel( root );
    puts("");

    printf("中序遍历（非递归）：");
    Inorder_Travel_No_Recursion( root );
    puts("");

    printf("后序遍历（递归）：  ");
    Postorder_Travel( root );
    puts("");

    printf("后序遍历（非递归）：");
    Postorder_Travel_No_Recursion( root );
    puts("\n");
}