数据结构之二叉树遍历

 最近学习了数据结构关于树的一些知识，发现很多的面试题考的都是树的非递归遍历，今天就总结了一下，代码如下所示：

#include<iostream>
#include<queue>
#include<stack> 
using namespace std;

typedef char status;
int index = 0; 
status str[24] ="A#B#C#D##";//ABC##DE#G##F###   ABDH#K###E##CFI###G#J##   ABCD#####   四组测试数据
typedef struct treeNode{
　　status data;
　　treeNode *lchild;
　　treeNode *rchild; 
}treeNode,*treelink;

/*初始化树*/
void Init(treelink *t){
*t = NULL;
}
/*创建二叉树*/
void Create_tree(treelink *t){
　　status ch;
　　ch = str[index++];

　　if(ch=='#'){
　　　　(*t) = NULL;
　　}else{
　　　　(*t) = (treelink)malloc(sizeof(treeNode));
　　　　if(!*t)exit(0);
　　　　(*t)->data = ch;
　　　　Create_tree(&(*t)->lchild);
　　　　Create_tree(&(*t)->rchild);
　　}
}

/*前序遍历递归实现*/
void Preordertraverse(treelink t){
　　if(!t)return ;
　　　　cout<<t->data;
　　Preordertraverse(t->lchild);
　　Preordertraverse(t->rchild);
}
/*前序遍历非递归实现*/
void Preordertraverse1(treelink t){
　　stack<treelink> s;
　　treelink p;
　　p = t;
　　while(!s.empty() || p!= NULL){
　　　　while(p!=NULL){
　　　　　　cout<<p->data;
　　　　　　s.push(p);
　　　　　　p=p->lchild;
　　　　}
　　　　if(!s.empty()){
　　　　　　p = s.top();
　　　　　　s.pop();
　　　　　　p = p->rchild; 
　　　　}
　　}
}


/*中序遍历递归实现*/
void Inordertraverse(treelink t){
　　if(!t)return ;
　　Inordertraverse(t->lchild);
　　cout<<t->data;
　　Inordertraverse(t->rchild);
}
/*中序遍历非递归实现*/
void Inordertraverse1(treelink t){
　　stack<treelink> s;
　　treelink p;
　　p = t;
　　while(!s.empty() || p!= NULL){
　　　　while(p!=NULL){
　　　　　　s.push(p);
　　　　　　p=p->lchild;
　　　　}
　　　　if(!s.empty()){
　　　　　　p = s.top();
　　　　　　cout<<p->data;
　　　　　　s.pop();
　　　　　　p = p->rchild; 
　　　　}
　　}
}

/*后序遍历递归实现*/
void Postordertraverse(treelink t){
　　if(!t)return ;
　　Postordertraverse(t->lchild);
　　Postordertraverse(t->rchild);
　　cout<<t->data;
}
/*后序遍历非递归实现*/
void Postordertraverse1(treelink t){
　　stack<treelink> s;
　　treelink cur,pre = NULL;
　　s.push(t);
　　while(!s.empty()){
　　　　cur = s.top();
　　　　if((cur->lchild == NULL && cur->rchild == NULL) || (pre!=NULL && (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);
　　　　　　} 
　　　　}
　　}
}
/*层次遍历非递归实现*/
void levelorder(treelink t){
　　queue<treelink> qu;
　　qu.push(t);
　　do{
　　　　treelink n = qu.front();
　　　　cout<<n->data;
　　　　qu.pop();
　　　　if(n->lchild!=NULL){
　　　　　　qu.push(n->lchild);
　　　　}
　　　　if(n->rchild!=NULL){
　　　　　　qu.push(n->rchild);
　　　　}
　　}while(!qu.empty());
}
/*分层打印*/
void level(treelink t){
　　queue<treelink> qu;
　　treelink m,n;
　　treelink p = (treelink)malloc(sizeof(treeNode));
　　p->data = '*'; 
　　qu.push(t);
　　qu.push(p);
　　do{
　　　　n = qu.front();
　　　　qu.pop();
　　　　if( n && n->data == '*'){
　　　　　　m = qu.back(); //可以使用qu.size()函数判断队里元素是否为1（*）如果是*的话就break 
　　　　　　if(n == m)break;
　　　　　　qu.push(p);
　　　　　　cout<<endl;
　　　　　　continue;
　　　　}else{
　　　　　　cout<<n->data;
　　　　}    
　　　　if(n->lchild != NULL){
　　　　　　qu.push(n->lchild);
　　　　}
　　　　if(n->rchild!=NULL){
　　　　　　qu.push(n->rchild);
　　　　}
　　}while(!qu.empty());
} 


/*求树的深度*/ 
int Tdepth(treelink t){
　　if(!t)return 0;
　　int ldepth = Tdepth(t->lchild);
　　int rdepth = Tdepth(t->rchild);
　　return 1 + max(ldepth,rdepth); 
}
/*递归实现求树指定层的节点*/
void printatlevel(treelink t,int level){
　　if(!t || level <0){
　　　　return ;
　　}
　　if(level == 0){
　　　　cout<<t->data;
　　}

　　printatlevel(t->lchild,level - 1);
　　printatlevel(t->rchild,level - 1);
}
/*分层打印二叉树*/
void printbylevel(treelink t){
　　int i;
　　int level = Tdepth(t);
　　for(i = 0;i<level;i++){
　　　　printatlevel(t,i);
　　　　cout<<endl;
　　}
}
int main(){
　　treelink t;
　　Init(&t);
　　Create_tree(&t);    
　　cout<<endl;
　　Postordertraverse1(t);
　　/*
　　Preordertraverse(t);
　　cout<<endl;
　　Preordertraverse1(t);
　　cout<<endl;
　　Inordertraverse(t);
　　cout<<endl;
　　Inordertraverse1(t);
　　cout<<endl;
　　Postordertraverse(t);
　　cout<<endl;
　　Postordertraverse1(t);
　　cout<<endl;
　　levelorder(t);
　　cout<<endl;
　　printbylevel(t);
　　cout<<endl;
　　level(t);*/
　　return 0;
}