二叉树的四种遍历方法（前序遍历的递归与非递归、中序遍历的递归与非递归、后序遍历的递归与非递归、层次遍历）

//算法5.2 中序遍历的非递归算法
#include<bits/stdc++.h>
using namespace std;

//二叉树的二叉链表存储表示
typedef struct BiNode
{				
	char data;						//结点数据域
	struct BiNode *lchild,*rchild;	//左右孩子指针
}BiTNode,*BiTree;

//链栈的定义
typedef struct StackNode
{
	BiTNode data;
    bool tag;
	struct StackNode *next;
}StackNode,*LinkStack;

// 队列的定义
typedef struct QNode{
    BiTree data;
    struct QNode* next;
}*Queue,QNode;

Queue rear=NULL;
void InitQ(Queue &Q)
{
    Q=NULL;
}
void addQ(Queue &Q,BiTree q)
{
    Queue p=new QNode;
    p->data=q;
	if(rear) rear->next=p;
	else Q=p;
	rear=p; 
    p->next=NULL;
    
}
BiTree delQ(Queue &Q)
{
    BiTree p=Q->data;
    if(!Q->next)
    {
    	Q=NULL;
    	rear=NULL;
	}
    else Q=Q->next;
    return p;
}
bool IsEmptyQ(Queue Q)
{
    return Q==NULL;
}
//用算法5.3 先序遍历的顺序建立二叉链表
void CreateBiTree(BiTree &T)
{	
	//按先序次序输入二叉树中结点的值（一个字符），创建二叉链表表示的二叉树T
	char ch;
	cin >> ch;
	if(ch=='#')  T=NULL;			//递归结束，建空树
	else{							
		T=new BiTNode;
		T->data=ch;					//生成根结点
		CreateBiTree(T->lchild);	//递归创建左子树
		CreateBiTree(T->rchild);	//递归创建右子树
	}								//else
}									//CreateBiTree

void InitStack(LinkStack &S)
{
	//构造一个空栈S，栈顶指针置空
	S=NULL;
}

bool StackEmpty(LinkStack S)
{
	if(!S)
		return true;
	return false;
}

void Push(LinkStack &S,BiTree e)
{
	//在栈顶插入元素*e
	StackNode *p=new StackNode;
	p->data=*e;
	p->next=S;
	p->tag=0;
	S=p;
}
void Pop(LinkStack &S,BiTree e)
{
	if(S!=NULL)//原书上写的是if(S==NULL)return ERROR;
	{	
		*e=S->data;
		StackNode *p=S;
		S=S->next;
		delete p;
	}
} 


void PreTeaversal0(BiTree T)//先序递归
{
    if(T)
    {
        cout<<T->data;
        PreTeaversal0(T->lchild);
        PreTeaversal0(T->rchild);
    }
}

void PreTeaversal1(BiTree T)//先序非递归
{
    LinkStack S;
    InitStack(S);
    BiTree P=T;
    BiTree q=(BiTree)malloc(sizeof(BiTNode));
    while(P||!StackEmpty(S))
    {
        while(P)
        {
            Push(S,P);
            cout<<P->data;
            P=P->lchild;
        }
        if(!StackEmpty(S))
        {
            Pop(S,q);
            P=q->rchild;
        }
    }
}
void InOrderTraverse1(BiTree T)
{ 
  // 中序遍历二叉树T的非递归算法
	/********************************Begin*********************************/
    LinkStack S;
    InitStack(S);
    BiTree P=T;
    BiTree q=new BiTNode;
    while(P||!StackEmpty(S))
    {
        while(P)
        {
            Push(S,P);
            P=P->lchild;
        }
        if(!StackEmpty(S)){
            Pop(S,q);
            cout<<q->data;
            P=q->rchild;
        }
    }
    /********************************End**********************************/
}									// InOrderTraverse

void PostTeaversal0(BiTree T)//后序递归
{
    if(T)
    {   
        PostTeaversal0(T->lchild);
        PostTeaversal0(T->rchild);
        cout<<T->data;
    }
}

void PostTeaversal1(BiTree T)//后序非递归
{
    LinkStack S;
    InitStack(S);
    BiTree P=T;
    BiTree q=(BiTree)malloc(sizeof(BiTNode));
    while(P||!StackEmpty(S))
    {
        while(P)
        {
            Push(S,P);
            P=P->lchild;
        }
        if(!StackEmpty(S))
        {
            if(S->tag)
            {
                Pop(S,q);
                cout<<q->data;
            }
            else
            {
                Pop(S,q);
                Push(S,q);
                S->tag=1;
                P=q->rchild;
            }
        }
    }
}

//层次遍历
void LevelOrderTraversal(BiTree T)
{
    if(T)
    {
        Queue Q;
        InitQ(Q);
        addQ(Q,T);
        Q=rear;
        while(!IsEmptyQ(Q))
        {
            T=delQ(Q);
            cout<<T->data;
            if(T->lchild)
			{
				//cout<<endl<<(T->lchild)->data<<endl;
				addQ(Q,T->lchild);
			 } 
            if(T->rchild)
			{
				//cout<<endl<<(T->rchild)->data<<endl;
				addQ(Q,T->rchild);
				
			 } 
        }
    }
    
}
int main()
{
	BiTree tree;
	CreateBiTree(tree);
	InOrderTraverse1(tree);
    cout<<endl;
	//LevelOrderTraversal(tree);
    /*PreTeaversal0(tree);
    cout<<endl;
    PreTeaversal1(tree);
    cout<<endl;
    PostTeaversal0(tree);
    cout<<endl;
    PostTeaversal1(tree);
    cout<<endl;*/
    
}