二叉树代码

#include <iostream>
#include <stack>
#include<queue>
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define maxSize 50
typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode, *BiTree;


void CreatBiTree(BiTree &T)//前序输入创建二叉树
{
    char ch;
    cin >> ch;
    if(ch == '#')
        T = NULL;
    else
    {
        T = new BiTNode;
        T->data = ch;
        CreatBiTree(T->lchild);
        CreatBiTree(T->rchild);
    }
}
void PerOrderTraverse(BiTree p)//递归前序遍历
{
    if(p != NULL)
    {
        cout << p->data <<" ";
        PerOrderTraverse(p->lchild);
        PerOrderTraverse(p->rchild);
    }
}
void InOrderTraverse(BiTree T)//递归中序遍历
{
    if( T != NULL )
    {
        InOrderTraverse(T->lchild);
        cout << T->data << " ";
        InOrderTraverse(T->rchild);
    }
}
void PostOrderTraverse(BiTree T)//递归后序遍历
{
    if(T != NULL)	//跳出递归条件 
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout << T->data << " ";
    }
}



int inOrderTraverse(BiTree T)//迭代中序遍历
{
    stack<BiTree> S;
    S.push(T);
	while(!S.empty())
	{
		while(S.top())
        {
            T = T->lchild;
            S.push(T);
        }
		S.pop();
		if(!S.empty())
        {
            T = S.top();
            cout << T->data << " ";
            S.pop();
            T = T->rchild;
            S.push(T);
        }
	}
	return 1;
}

void inorderNorecursion(BiTree T)//迭代中序遍历2
{
	if(T != NULL)
	{
		BiTree Stack[maxSize];
		int top = -1;
		BiTree p;
		p = T;
		while (top != -1 || p != NULL)
		{
			while (p != NULL)
			{
				Stack[++top] = p;
				p = p->lchild;
			}
			if(top != -1)
			{
				p = Stack[top--];
				cout << p->data << " ";
				p = p->rchild;
			}
		}
	}
}


int PreorderNonrecursion(BiTree T)//非递归先序遍历算法
{
	BiTree Stack[maxSize];
	int top = -1;
	BiTree p;
	Stack[++top] = T;
	while(top != -1)
	{
		p = Stack[top--];
		cout << p->data << " ";
		if(p->rchild)
		Stack[++top] = p->rchild;
		if(p->lchild)
		Stack[++top] = p->lchild;
	}
}


void postorderNonrecursion(BiTree T)//非递归后序 
{
	if(T != NULL)
	{
		BiTree Stack1[maxSize];
		BiTree Stack2[maxSize];
		
		int top1 = -1;
		int top2 = -1;
		BiTree p = NULL;
		
		Stack1[++top1] = T;
		while(top1 != -1)
		{
			p = Stack1[top1--];
			Stack2[++top2] = p;
			if(p->lchild != NULL)
				Stack1[++top1] = p->lchild;
			if(p->rchild != NULL)
				Stack1[++top1] = p->rchild;
		}
		while (top2 != -1)
		{
			p = Stack2[top2--];
			cout << p->data << " ";
		}
	}
}


void LevelOrderTraverse(BiTree T)//层序遍历 
{
	queue<BiTree> Q;			//创建一个队列
    Q.push(T);					//先压入第一个节点
    while(!Q.empty())			// 队列不为空
    {
        T = Q.front();		 	//T指向队首元素
        cout << T->data << " "; //输出队首元素
        Q.pop();				//弹出队首元素 
       	if(T->lchild)			//T的左孩子不为空（有左子树） 
           Q.push(T->lchild);	//T的左孩子压入队列 
       	if(T->rchild)			//T的右孩子不为空（有右子树） 
           Q.push(T->rchild);	//T的右孩子压入队列 
    }
}


int GetDepth(BiTree T)//求树深度
{
    int LD = 0,RD = 0;
    if(T == NULL)
        return 0;
    else
    {
        LD = GetDepth(T->lchild);
        RD = GetDepth(T->rchild);
        if(LD >= RD)
        return LD + 1;
        else
        return RD + 1;
    }
}



void CountLeaf(BiTree root, int &number)//叶子节点 
{

    if(root != NULL)
    {
        if(!root->lchild && !root->rchild)
        {
            number++;
            cout << root->data << " ";
        }
        if(root->lchild)
            CountLeaf(root->lchild, number);
        if(root->rchild)
            CountLeaf(root->rchild, number);
    }
}


void Postorder(BiTree T)//非递归后序遍历 
{
    BiTree Seqstack[maxSize];
    int top = -1;
    int flag = 1;
    BiTree p;
    if(T != NULL)
    {
       	do
        {
            while(T != NULL)                    // 循环，将所有最左结点压栈
            {
                top ++;
                Seqstack[top] = T;
                T = T->lchild;
            }
            flag = 1;                           // 辅助变量flag为1表示当前结点的左孩子为空或者已被访问
            p = NULL;                           // 指针变量p指向当前结点的前驱结点
            while(top > -1&& flag == 1)
            {
                T = Seqstack[top];              // 注意：这里只是获取栈顶元素，而并没有出栈
                if(T->rchild == p)              // 如果当前结点右孩子为空，或者已经被访问过，则访问当前结点
                {
                    top --;                     // 当前结点出栈
                    cout << T->data << " ";
                    p = T;                      // 指针变量指向当前结点
                }
                else                            // 如果当前结点右孩子不为空，则先去处理右孩子
                {
                    T = T->rchild;              // 处理右孩子
                    flag = 0;                   // T的左孩子未被访问，flag置为0
                }
            }
        }while(top > -1);
    }
}

void postOrder3(BiTree root)     //非递归后序遍历
{
    stack<BiTree> s;
    BiTree cur;                      //当前结点 
    BiTree pre=NULL;                 //前一次访问的结点 
    s.push(root);
    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);
        }
    }    
}

int main(){
    BiTree T;
    cout << "请按照前序遍历法输入二叉树，用#补齐" << endl;
    CreatBiTree(T);
    cout << endl;
    cout << "前序递归遍历结果：" ;
    PerOrderTraverse(T);
	cout << "	";
    cout << "非递归先序遍历结果：" ; 
    PreorderNonrecursion(T);
    cout << endl;
    
    cout << "中序递归遍历结果：" ;
    InOrderTraverse(T);
    cout << "	";
    cout << "非递归中序遍历结果：";
   	inorderNorecursion(T);
    cout << endl;
    
    cout << "后续递归遍历结果：" ;
    PostOrderTraverse(T);
    cout << "	";
    cout << "非递归后续遍历结果：";
	postOrder3(T);
	//Postorder(T); 
	//postorderNonrecursion(T); 
	cout << endl;
    
    
    cout << "层序遍历结果为：";
    LevelOrderTraverse(T);
    cout << endl;
    
    
    cout << "树深为：" ;
    int depth;
    depth = GetDepth(T);
    cout << depth <<endl;
    cout << "树的叶子节点为：" ;
    int number = 0; 
    CountLeaf(T, number);
    cout << endl;
    cout << "树的叶子节点的个数为：" << number << endl; 
    return 0;
}