二叉树前序、中序、后序、层次遍历

转自：http://blog.csdn.net/that163/article/details/8040009

分别用了三种不同的方法实现了二叉树的前序遍历。

#include<iostream>
 #include<stack>
 using namespace std;
 struct BTreeNode{
     //二叉树
     int data;
     BTreeNode *lchild;
     BTreeNode *rchild;
     BTreeNode *parent;
 };
 /*
 void PreOrder(BTreeNode *t){
     //递归方法
     if(t == NULL)return ;
     cout<<t->data<<' ';
     PreOrder(t->lchild);
     PreOrder(t->rchild);
 }
 */
 /*
 void PreOrder(BTreeNode *t){
     //用栈，采取先放右子树再放左子树的方法，达到输出时先左后右
     stack<BTreeNode*> s;
     BTreeNode *temp;
     if(t == NULL)return ;
     s.push(t);
     while(!s.empty()){
         temp = s.top();
         s.pop();
         cout<<temp->data<<' ';
         if(temp->rchild != NULL)s.push(temp->rchild);
         if(temp->lchild != NULL)s.push(temp->lchild);
     }
 }
 */
 void PreOrder(BTreeNode *t){
     //不断往左走并访问，直到无法走后，回溯到先一个结点的右边，再重复
     stack<BTreeNode*> s;
     BTreeNode *temp;
     while(t != NULL || !s.empty()){
         while(t != NULL){
             cout<<t->data<<" ";
             s.push(t);
             t = t->lchild;
         }
         if(!s.empty()){
             t = s.top();
             s.pop();
             t = t->rchild;
         }
     }
 }
 int main(){
     return 0;
 }
View Code

分别用了三种不同的方法实现了二叉树的中序遍历。

/*
input:
2
10 5 4 -1 -1 -1 20 19 -1 -1 40 -1 -1
30 10 8 20 -1 -1 -1 -1 50 40 -1 45 -1 -1 -1
output:
4 5 10 19 20 40
20 8 10 30 40 45 50
*/
#include<iostream>
#include<stack>
using namespace std;
struct BTreeNode{
    //二叉树
    int data;
    BTreeNode *lchild;
    BTreeNode *rchild;
};
struct snode{
    //设置访问标识
    BTreeNode *node;
    bool flag;
};
/*
void InOrder(BTreeNode *t){
    //递归方法
    if(t == NULL)return ;
    InOrder(t->lchild);
    cout<<t->data<<' ';
    InOrder(t->rchild);
}
*/
/*
void InOrder(BTreeNode *t){
    //不断访问其左子树，然后输出其根，然后访问其接着的右子树，重复过程
    stack<BTreeNode*> s;
    while(!s.empty() || t != NULL){
        while(t != NULL){
            s.push(t);
            t = t->lchild;
        }
        if(!s.empty()){
            t = s.top();
            s.pop();
            cout<<t->data<<' ';
            t = t->rchild;
        }
    }
}
*/
void InOrder(BTreeNode *t){
    //按右根左的存放方式存入栈，根据栈的特性输出中序遍历。注意第一次放入的是根，第二次放入才调整其位置。
    stack<snode> s;
    snode temp,ltemp,rtemp;
    temp.flag = false;
    temp.node = t;
    s.push(temp);
    while(!s.empty()){
        temp = s.top();
        s.pop();
        if(temp.flag)cout<<temp.node->data<<' ';
        else{
            if(temp.node->rchild != NULL){
                rtemp.flag = false;
                rtemp.node = temp.node->rchild;
                s.push(rtemp);
            }
            temp.flag = true;
            s.push(temp);
            if(temp.node->lchild != NULL){
                ltemp.flag = false;
                ltemp.node = temp.node->lchild;
                s.push(ltemp);
            }
        }
    }
}
void Create(BTreeNode *&t){
    //（测试用）以先序遍历构建二叉树
    int x;
    cin>>x;
    if(x == -1)
        t = NULL;
    else
    {
        t = new BTreeNode;
        t->data = x;
        Create(t->lchild);
        Create(t->rchild);
    }
}
int main(){
    BTreeNode *root = NULL;
    int t;
    cin>>t;
    while(t--)
    {
        Create(root);
        InOrder(root);
        cout<<endl;
    }
    return 0;
}

 分别用了三种不同的方法实现了二叉树的后序遍历。

/*
input:
2
10 5 4 -1 -1 -1 20 19 -1 -1 40 -1 -1
30 10 8 20 -1 -1 -1 -1 50 40 -1 45 -1 -1 -1
output:
4 5 19 40 20 10
20 8 10 45 40 50 30
*/
#include<iostream>
#include<stack>
using namespace std;
struct BTreeNode{
    //二叉树
    int data;
    BTreeNode *lchild;
    BTreeNode *rchild;
    BTreeNode *parent;
};
struct snode{
    //设置访问标识
    BTreeNode *node;
    bool flag;
};
/*
void PostOrder(BTreeNode *t){
    //递归方法
    if(t == NULL)return ;
    PostOrder(t->lchild);
    PostOrder(t->rchild);
    cout<<t->data<<' ';
}
*/
/*
void PostOrder(BTreeNode *t){
    //设置访问标识，第一次为访问完左子树，第二次为访问完右子树。二次访问即刻输出结点。
    stack<snode> s;
    snode temp;
    while(!s.empty() || t != NULL){
        while(t != NULL){
            temp.node = t;
            temp.flag = false;
            s.push(temp);
            t = t->lchild;
        }
        if(!s.empty()){
            temp = s.top();
            s.pop();
            t = temp.node;
            if(temp.flag){
                cout<<t->data<<' ';
                t = NULL;
            }
            else{
                temp.flag = true;
                s.push(temp);
                t = t->rchild;
            }
        }
    }
}
*/
void PostOrder(BTreeNode *t){
    //采取根右左的存放方式，用栈实现后序遍历。设置访问标识，注意第一次放入栈，放入的是根，第二次调整其顺序。
    stack<snode> s;
    snode temp,ltemp,rtemp;
    temp.node = t;
    temp.flag = false;
    s.push(temp);
    while(!s.empty()){
        temp = s.top();
        s.pop();
        if(temp.flag)cout<<temp.node->data<<' ';
        else{
            temp.flag = true;
            s.push(temp);
            if(temp.node->rchild != NULL){
                rtemp.flag = false;
                rtemp.node = temp.node->rchild;
                s.push(rtemp);
            }
            if(temp.node->lchild != NULL){
                ltemp.flag = false;
                ltemp.node = temp.node->lchild;
                s.push(ltemp);
            }

        }
    }
}
void Create(BTreeNode *&t){
    //（测试用）以先序遍历构建二叉树
    int x;
    cin>>x;
    if(x == -1)
        t = NULL;
    else
    {
        t = new BTreeNode;
        t->data = x;
        Create(t->lchild);
        Create(t->rchild);
    }
}
int main(){
    BTreeNode *root = NULL;
    int t;
    cin>>t;
    while(t--)
    {
        Create(root);
        PostOrder(root);
        cout<<endl;
    }
    return 0;
} 

二叉树层次遍历

/*
二叉树的层次遍历
input:
2
10 5 4 -1 -1 -1 20 19 -1 -1 40 -1 -1
30 10 8 20 -1 -1 -1 -1 50 40 -1 45 -1 -1 -1
output:
10 5 20 4 19 40
30 10 50 8 40 20 45
*/
#include<iostream>
#include<queue>
using namespace std;
struct BTreeNode{
    //二叉树
    int data;
    BTreeNode *lchild;
    BTreeNode *rchild;
};
void LayerOrder(BTreeNode *t){
    //利用队列实现层次遍历，每次访问根结点，然后一次放入左结点和右结点（如果有的话）。
    if(t == NULL)return ;
    queue<BTreeNode*> q;
    BTreeNode *temp;
    q.push(t);
    while(!q.empty()){
        temp = q.front();
        q.pop();
        cout<<temp->data<<' ';
        if(temp->lchild != NULL)q.push(temp->lchild);
        if(temp->rchild != NULL)q.push(temp->rchild);
    }
}
void Create(BTreeNode *&t){
    //（测试用）以先序遍历构建二叉树
    int x;
    cin>>x;
    if(x == -1)
        t = NULL;
    else
    {
        t = new BTreeNode;
        t->data = x;
        Create(t->lchild);
        Create(t->rchild);
    }
}
int main(){
    BTreeNode *root = NULL;
    int t;
    cin>>t;
    while(t--)
    {
        Create(root);
        LayerOrder(root);
        cout<<endl;
    }
    return 0;
}