二叉树的遍历（前、中、后、层次）递归与非递归实现

二叉树的遍历

前序

递归：

void PreOrder(BTNode *root)
{
	if(root!=NULL){
	    cout<<root->data;
	    PreOrder( root->lchild );
	    PreOrder( root->rchild );
   	}

}

非递归：利用栈帮助我们实现，遍历左子树，直到为空，
也就是这棵树的最左边，然后访问右子树，访问完毕就回到上一层。

void PreOrder_(BTNode *root){
    stack<BTNode*>s;
    BTNode *p=root;
    while(p!=NULL||!s.empty()){
        while(p!=NULL){
            cout<<p->data;
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty()){
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
    cout<<endl;
}

中序

递归：

void InOrder (BTNode *root)
{
	if(root!=NULL){
	    InOrder( root->lchild );
	    cout<<root->data;
	    InOrder( root->rchild );
   	}

}

非递归：跟前序遍历差不多，也是先找到当前树的最左边，然后访问右子树，访问完毕就回到上一层，只是在访问的时候不应该输出根节点的值。

void InOrder_ (BTNode *root){
    stack<BTNode*>s;
    BTNode *p=root;
    while(p!=NULL||!s.empty()){
        while(p!=NULL){
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty()){
            p=s.top();
            s.pop();
            cout<<p->data;
            p=p->rchild;
        }
    }
    cout<<endl;
}

后序

递归：

void PostOrder (BTNode *root)
{
	if(root!=NULL){
	    PostOrder( root->lchild );
	    PostOrder( root->rchild );
		cout<<root->data;
   	}

}

非递归：如果当前节点为树叶或者前一次访问为当前节点的孩子节点直接输出，出栈。然后将孩子节点加入栈，左孩子在最后加入

void PostOrder_ (BTNode *root){
    stack<BTNode*>s;
    BTNode *cur;//当前节点
    BTNode *pre=NULL;//前一次访问的节点
    s.push(root);
    while(!s.empty()){
        cur=s.top();
        if((cur->lchild==NULL&&cur->rchild==NULL)||
           (pre&&(pre==cur->lchild||pre==cur->rchild))){
               cout<<cur->data;
               s.pop();
               pre=cur;
           }
        else{
            if(cur->rchild!=NULL)s.push(cur->rchild);
            if(cur->lchild!=NULL)s.push(cur->lchild);
        }
    }
    cout<<endl;
}

层次遍历：

思路：利用队列，先将第一层放入队列。遍历队列输出，同时把孩子节点放入一个临时队列中，遍历完更新下一层的节点队列。

void levelOrder(BTNode *root){
    BTNode *cur;
    queue<BTNode *> que;

    que.push(root);
    while(!que.empty()){
        queue<BTNode *> t;
        while(!que.empty())
        {
            cur=que.front();
            que.pop();
            cout<<cur->data;
            if(cur->lchild)t.push(cur->lchild);
            if(cur->rchild)t.push(cur->rchild);
        }
        que=t;
        cout<<endl;
    }
    cout<<endl;
}

完整代码：

#include <bits/stdc++.h>

using namespace std;
typedef char ElemType;

typedef struct Node{
	ElemType data;    //数据域
	struct Node *lchild;
	struct Node *rchild; //结点的左右子树指针
}BTNode;//二叉树结点类型

//初始化空二叉树
void TreeInit(BTNode* &root)
{
	root=NULL;
}

//按照前序遍历序列建立二叉树
void CreateBTree_Pre(BTNode* &root, ElemType Array[])
{
	static int count=0;	//静态变量count
    char item=Array[count];//读取Array[]数组中的第count个元素
	count++;
	if(item == '#') //如果读入#字符，创建空树
	{ root = NULL; return ;}
    else
	{
		root = new BTNode;
        root->data = item;
	    CreateBTree_Pre (root->lchild,Array); //建左子树
	    CreateBTree_Pre (root->rchild,Array); //建右子树
 	 }
}
//递归
//前序遍历二叉树
void PreOrder(BTNode *root)
{
	if(root!=NULL){
	    cout<<root->data;
	    PreOrder( root->lchild );
	    PreOrder( root->rchild );
   	}

}
//中序遍历
void InOrder (BTNode *root)
{
	if(root!=NULL){
	    InOrder( root->lchild );
	    cout<<root->data;
	    InOrder( root->rchild );
   	}

}
//后序遍历
void PostOrder (BTNode *root)
{
	if(root!=NULL){
	    PostOrder( root->lchild );
	    PostOrder( root->rchild );
		cout<<root->data;
   	}

}
//非递归前序
void PreOrder_(BTNode *root){
    stack<BTNode*>s;
    BTNode *p=root;
    while(p!=NULL||!s.empty()){
        while(p!=NULL){
            cout<<p->data;
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty()){
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
    cout<<endl;
}
//非递归中序
void InOrder_ (BTNode *root){
    stack<BTNode*>s;
    BTNode *p=root;
    while(p!=NULL||!s.empty()){
        while(p!=NULL){
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty()){
            p=s.top();
            s.pop();
            cout<<p->data;
            p=p->rchild;
        }
    }
    cout<<endl;
}
void PostOrder_ (BTNode *root){
    stack<BTNode*>s;
    BTNode *cur;//当前节点
    BTNode *pre=NULL;//前一次访问的节点
    s.push(root);
    while(!s.empty()){
        cur=s.top();
        if((cur->lchild==NULL&&cur->rchild==NULL)||
           (pre&&(pre==cur->lchild||pre==cur->rchild))){
               cout<<cur->data;
               s.pop();
               pre=cur;
           }
        else{
            if(cur->rchild!=NULL)s.push(cur->rchild);
            if(cur->lchild!=NULL)s.push(cur->lchild);
        }
    }
    cout<<endl;
}
//层次遍历
void levelOrder(BTNode *root){
    BTNode *cur;
    queue<BTNode *> que;

    que.push(root);
    while(!que.empty()){
        queue<BTNode *> t;
        while(!que.empty())
        {
            cur=que.front();
            que.pop();
            cout<<cur->data;
            if(cur->lchild)t.push(cur->lchild);
            if(cur->rchild)t.push(cur->rchild);
        }
        que=t;
        cout<<endl;
    }
    cout<<endl;
}
int main()
{
    BTNode *root;
	ElemType A[]="ABD##E##CF#G###";//以"#"补充空分支后的某个遍历序列
	TreeInit(root);//初始化空二叉树
	CreateBTree_Pre(root,A);//以前序遍历序列建立二叉树
	PreOrder(root);
    cout<<endl;
	PreOrder_(root);
	InOrder(root);
    cout<<endl;
	InOrder_(root);
	PostOrder(root);
	cout<<endl;
	PostOrder_(root);
	levelOrder(root);
    return 0;
}