二叉查找树的遍历总结

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


先序遍历:  先根,再左子树,最后右子树;

中序遍历:  先左子树,再根,最后右子树;

后序遍历:  先左子树, 再右子树,最后根;


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

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

两者共同点: 对节点的遍历次序一致;

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


中序遍历的非递归方式:

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

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


后序遍历的非递归方式

我的做法是对树取反,即左子权值 > 根权值 > 右子权值, 对该反树先序遍历的序列取反即是原来树的后序遍历我只需要在先序遍历的非递归方式中把左右入栈的顺序改变即可,同时新开一个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");
}



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值