#include<stdio.h>
#include <stdlib.h>
#include<iostream>
#define MAXSIZE  1024
#define MAXNODE  1024
using namespace std;
typedef struct BiTNode
{
  char  data;
  struct BiTNode *lchild,*rchild;    /*左右孩子指针*/
}BiTNode,*BiTree;

 int Initiate (BiTree bt)
    {/*初始化建立二叉树*bt的头结点*/
         if((bt=(BiTNode*)malloc(sizeof(BiTNode)))==NULL)
                return 0;
         bt->lchild=NULL;
         bt->rchild=NULL;
         return 1;
}
 
void PreOrder(BiTree bt)
{  /*先序遍历二叉树bt*/
  if (bt==NULL) return;     /*递归调用的结束条件*/
Visite(bt->data);       /*访问结点的数据域*/
  PreOrder(bt->lchild);   /*先序递归遍历bt的左子树*/
  PreOrder(bt->rchild);   /*先序递归遍历bt的右子树*/  
}
void InOrder(BiTree bt)
{  /*中序遍历二叉树bt*/
  if (bt==NULL) return;     /*递归调用的结束条件*/
  Visite(bt->data);       /*访问结点的数据域*/
  PreOrder(bt->lchild);   /*先序递归遍历bt的左子树*/
  PreOrder(bt->rchild);   /*先序递归遍历bt的右子树*/  
}
void PostOrder(BiTree bt)
{  /*后序遍历二叉树bt*/
    if (bt==NULL) return;     /*递归调用的结束条件*/
    PostOrder(bt->lchild);   /*后序递归遍历bt的左子树*/
    PostOrder(bt->rchild);   /*后序递归遍历bt的右子树*/  
    Visite(bt->data);       /*访问结点的数据域*/
}
void LevelOrder(BiTree bt,int q)
    /*层次遍历二叉树bt*/
{ Queue :q=Init_Queue();
    int front,rear;
     if (bt==NULL) return;
        In_Queue(q,bt);
          BiTree x;
      while(!Empty_Queue(q))
         {OutQueue(q,&x);
          Visite(x->data);    /*访问队首结点的数据域*/
          if (x->lchild!=NULL)   /*将队首结点的左孩子结点入队列*/
           {
                  In_Queue(q, x->lchild);
            }
          if (x->rchild!=NULL)   /*将队首结点的右孩子结点入队列*/
           {
    In_Queue(q, x->rchild);
            }
         }
         Destroy_Queue(&q);
}
void NRPreOrder(BiTree bt)
{/*非递归先序遍历二叉树*/
    BiTree stack[MAXSIZE],p;
    int top;
    if(bt==NULL)return;
    top=0;
    p=bt;
    while(!(p=NULL&&top==0))
    {
        while(p!=NULL)
        {
                  /*访问节点的数据域*/
            if(top<MAXNODE-1)     /*将当前指针p压栈*/
            {
                stack[top]=p;
                top++;
            }
        else{
            printf("栈溢出");
            return;
        }
        p=p->lchild;             /*指针指向p的左孩子*/
        }
        if(top<=0)return;       /*栈空时结束*/
        else{
            top--;
            p=stack[top];       /*从栈中弹出栈顶元素*/
             Visite(p->data);     
            p=p->rchild;       /*指针指向p的右孩子节点*/
        }
    }
}
void Destroy (BiTree *bt)
   {
          if(*bt)
           {
                  Destroy(&(*bt)->lchild);
                  Destroy(&(*bt)->rchild);
                  free(*bt);
             }
             *bt=NULL;
}
int main()
{
   
}

求助 求助
#include<stdio.h>
#include <stdlib.h>
#include<iostream>
#define MAXSIZE  1024
#define MAXNODE  1024
using namespace std;
typedef struct BiTNode
{
  char  data;
  struct BiTNode *lchild,*rchild;    /*左右孩子指针*/
}BiTNode,*BiTree;

 int Initiate (BiTree bt)
    {/*初始化建立二叉树*bt的头结点*/
         if((bt=(BiTNode*)malloc(sizeof(BiTNode)))==NULL)
                return 0;
         bt->lchild=NULL;
         bt->rchild=NULL;
         return 1;
}
 
void PreOrder(BiTree bt)
{  /*先序遍历二叉树bt*/
  if (bt==NULL) return;     /*递归调用的结束条件*/
Visite(bt->data);       /*访问结点的数据域*/
  PreOrder(bt->lchild);   /*先序递归遍历bt的左子树*/
  PreOrder(bt->rchild);   /*先序递归遍历bt的右子树*/  
}
void InOrder(BiTree bt)
{  /*中序遍历二叉树bt*/
  if (bt==NULL) return;     /*递归调用的结束条件*/
         /*访问结点的数据域*/
  PreOrder(bt->lchild);/*先序递归遍历bt的左子树*/
   Visite(bt->data);  
  PreOrder(bt->rchild);   /*先序递归遍历bt的右子树*/  
}
void PostOrder(BiTree bt)
{  /*后序遍历二叉树bt*/
    if (bt==NULL) return;     /*递归调用的结束条件*/
    PostOrder(bt->lchild);   /*后序递归遍历bt的左子树*/
    PostOrder(bt->rchild);   /*后序递归遍历bt的右子树*/  
    Visite(bt->data);       /*访问结点的数据域*/
}
void LevelOrder(BiTree bt,int q)
    /*层次遍历二叉树bt*/
{ Queue :q=Init_Queue();
    int front,rear;
     if (bt==NULL) return;
        In_Queue(q,bt);
          BiTree x;
      while(!Empty_Queue(q))
         {OutQueue(q,&x);
          Visite(x->data);    /*访问队首结点的数据域*/
          if (x->lchild!=NULL)   /*将队首结点的左孩子结点入队列*/
           {
                  In_Queue(q, x->lchild);
            }
          if (x->rchild!=NULL)   /*将队首结点的右孩子结点入队列*/
           {
    In_Queue(q, x->rchild);
            }
         }
         Destroy_Queue(&q);
}
void NRPreOrder(BiTree bt)
{/*非递归先序遍历二叉树*/
    BiTree stack[MAXSIZE],p;
    int top;
    if(bt==NULL)return;
    top=0;
    p=bt;
    while(!(p=NULL&&top==0))
    {
        while(p!=NULL)
        {
                  /*访问节点的数据域*/
            if(top<MAXNODE-1)     /*将当前指针p压栈*/
            {
                stack[top]=p;
                top++;
            }
        else{
            printf("栈溢出");
            return;
        }
        p=p->lchild;             /*指针指向p的左孩子*/
        }
        if(top<=0)return;       /*栈空时结束*/
        else{
            top--;
            p=stack[top];       /*从栈中弹出栈顶元素*/
             Visite(p->data);     
            p=p->rchild;       /*指针指向p的右孩子节点*/
        }
    }
}
void Destroy (BiTree *bt)
   {
          if(*bt)
           {
                  Destroy(&(*bt)->lchild);
                  Destroy(&(*bt)->rchild);
                  free(*bt);
             }
             *bt=NULL;
}
int main()
{
   
}
以上是我修过的 错误均是函数未定义到底该怎么定义啊

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE  1024
#define MAXNODE  1024

typedef struct QueueNode
{
    char s[MAXSIZE];    /*队列存放数据*/
    int front;          /*队列头指针*/
    int rear;           /*队列尾指针*/

}QueueNode,*Queue;



typedef struct BiTNode
{
  char  data;
  struct BiTNode *lchild,*rchild;    /*左右孩子指针*/
}BiTNode,*BiTree;

Queue Init_Queue();                 /*队列初始化*/
void In_Queue(Queue q,BiTree bt);   /*入队*/
void OutQueue(Queue q,BiTree* x);   /*出队并取其数据*/
void Destroy_Queue(Queue* q);       /*销毁队列*/

int Empty_Queue(Queue q);           /*判断队列是否为空*/
int Full_Queue(Queue q);            /*判断队列是否为满*/


int Initiate (BiTree bt);           /*初始化二叉树*/
void PreOrder(BiTree bt);           /*前序遍历*/
void InOrder(BiTree bt);            /*中序遍历*/
void PostOrder(BiTree bt);          /*后序遍历*/
void LevelOrder(BiTree bt);         /*层次遍历*/
void NRPreOrder(BiTree bt);         /*非递归前序遍历*/
void NRInOrder(BiTree bt);         /*非递归中序遍历*/
void Destroy (BiTree* bt);          /*销毁二叉树*/

void Visite(char c)
{
    printf("%c",c);
}


int main()  /*主函数*/
{
    BiTree bt;  
    printf("请输入数据\n");  
   Initiate(bt);  
  
    printf("\n前序遍历结果：\n");  
    PreOrder(bt);  
    printf("\n前序非递归遍历结果：\n");  
    NRPreOrder(bt);  
  
    printf("\n中序遍历结果：\n");  
    InOrder(bt);  
    printf("\n中序非递归遍历结果：\n");  
    NRInOrder(bt);  
  
    printf("\n后序遍历结果：\n");  
    PostOrder(bt);  
   
   
}  


Queue Init_Queue()
{
    Queue p=(Queue)malloc(sizeof (QueueNode));

    if (p==NULL)
    {
        puts("申请空间失败!");
        return NULL;
    }

    memset(p->s,0,sizeof(p->s));

    p->front=p->rear=0;

    return p;
}

void In_Queue(Queue q,BiTree bt)   /*入队*/
{
    if (Full_Queue(q))
        return ;

    ++q->rear;
    q->rear%=MAXSIZE;
    bt->data=q->s[q->rear];
}

void OutQueue(Queue q,BiTree* bt)       /*出队*/
{
    if (Empty_Queue(q))
        return ;

    ++q->front;
    q->front%=MAXSIZE;
    (*bt)->data=q->s[q->front];

}

int Empty_Queue(Queue q)         /*判断队列是否为空*/
{
    return q->front==q->rear;
}

void Destroy_Queue(Queue* q)       /*销毁队列*/
{
    if (*q)
        free(*q);

    *q=NULL;
}

int Full_Queue(Queue q)
{
    return q->front==q->rear+1;  /*判断是否队满*/
}

int Initiate (BiTree bt)   /*初始化建立二叉树*bt的头结点*/
{   
    scanf("%d",&bt);  
   
   
     if((bt=(BiTNode*)malloc(sizeof(BiTNode)))==NULL)
            return 0;

     bt->lchild=NULL;
     bt->rchild=NULL;
     return 1;
}
 
void PreOrder(BiTree bt)       /*先序遍历二叉树bt*/
{  
  if (bt==NULL)
      return;                  /*递归调用的结束条件*/

  Visite(bt->data);           /*访问结点的数据域*/

  PreOrder(bt->lchild);       /*先序递归遍历bt的左子树*/
  PreOrder(bt->rchild);       /*先序递归遍历bt的右子树*/  
}
void InOrder(BiTree bt)       /*中序遍历二叉树bt*/
{
  if (bt==NULL)              /*递归调用的结束条件*/
      return;      
         
  PreOrder(bt->lchild);      /*先序递归遍历bt的左子树*/

  Visite(bt->data);          /*访问结点的数据域*/

  PreOrder(bt->rchild);      /*先序递归遍历bt的右子树*/  
}
void PostOrder(BiTree bt)    /*后序遍历二叉树bt*/
{  
    if (bt==NULL)            /*递归调用的结束条件*/
        return;   

    PostOrder(bt->lchild);   /*后序递归遍历bt的左子树*/
    PostOrder(bt->rchild);   /*后序递归遍历bt的右子树*/  

    Visite(bt->data);        /*访问结点的数据域*/
}
void LevelOrder(BiTree bt)   /*层次遍历二叉树bt*/
{
    Queue q=Init_Queue();    /*队列初始化*/

    BiTree x=0;                 /*队列暂存数据*/

     if (bt==NULL)
         return;

        In_Queue(q,bt);          /*入队*/

      while(!Empty_Queue(q))     /*如果队列不为空*/
      {
          OutQueue(q,&x);                     /*取出队列数据*/
          Visite(x->data);                    /*访问队首结点的数据域*/
          if (x->lchild!=NULL)                /*将队首结点的左孩子结点入队列*/
               In_Queue(q, x->lchild);

          if (x->rchild!=NULL)                /*将队首结点的右孩子结点入队列*/
              In_Queue(q, x->rchild);
      }
         Destroy_Queue(&q);                  
}
void NRPreOrder(BiTree bt)   /*非递归先序遍历二叉树*/
{
    BiTree stack[MAXSIZE]={0};
    BiTree p=NULL;

    int top=0;

    if(bt==NULL)
        return;

    p=bt;

    while(!(p=NULL&&top==0))
    {
        while(p!=NULL)
        {
                  /*访问结点的数据域*/
            if(top<MAXNODE-1)     /*将当前指针p压栈*/
            {
                stack[top]=p;
                top++;
            }
            else
            {
                printf("???");
                return;
            }

            p=p->lchild;             /*指针指向p的左孩子*/
        }

        if(top<=0)
            return;       /*栈空时结束*/
        else
        {
            top--;
            Visite(p->data);
              p=stack[top];       /*从栈中弹出栈顶元素*/
            p=p->rchild;       /*指针指向p的右孩子结点*/
        }
    }
}
void NRInOrder(BiTree bt)   /*非递归中序遍历二叉树*/
{
    BiTree stack[MAXSIZE]={0};
    BiTree p=NULL;

    int top=0;

    if(bt==NULL)
        return;

    p=bt;

    while(!(p=NULL&&top==0))
    {
        while(p!=NULL)
        {
                  /*访问结点的数据域*/
            if(top<MAXNODE-1)     /*将当前指针p压栈*/
            {
                stack[top]=p;
                top++;
            }
            else
            {
                printf("???");
                return;
            }

            p=p->lchild;             /*指针指向p的左孩子*/
        }

        if(top<=0)
            return;       /*栈空时结束*/
        else
        {
            top--;
            p=stack[top];       /*从栈中弹出栈顶元素*/
            Visite(p->data);     
            p=p->rchild;       /*指针指向p的右孩子结点*/
        }
    }
}
void Destroy (BiTree *bt)
{
      if(*bt)
      {
           Destroy(&(*bt)->lchild);
           Destroy(&(*bt)->rchild);
           free(*bt);
      }
      *bt=NULL;
}

谢谢你帮助我补充修改的代码
输入数据我打的也有很多错误可以再帮我看一下吗
求助

谢谢啦 我真的是一头雾水啊 好几天也搞不出来的作业啊

初始化那里有问题
要咋改呢

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE  1024
#define MAXNODE  1024

typedef struct QueueNode
{
    char s[MAXSIZE];    /*队列存放数据*/
    int front;          /*队列头指针*/
    int rear;           /*队列尾指针*/

}QueueNode,*Queue;



typedef struct BiTNode
{
  char  data;
  struct BiTNode *lchild,*rchild;    /*左右孩子指针*/
}BiTNode,*BiTree;

Queue Init_Queue();                 /*队列初始化*/
void In_Queue(Queue q,BiTree bt);   /*入队*/
void OutQueue(Queue q,BiTree* x);   /*出队并取其数据*/
void Destroy_Queue(Queue* q);       /*销毁队列*/

int Empty_Queue(Queue q);           /*判断队列是否为空*/
int Full_Queue(Queue q);            /*判断队列是否为满*/


int Initiate (BiTree bt);           /*初始化二叉树*/
void PreOrder(BiTree bt);           /*前序遍历*/
void InOrder(BiTree bt);            /*中序遍历*/
void PostOrder(BiTree bt);          /*后序遍历*/
void LevelOrder(BiTree bt);         /*层次遍历*/
void NRPreOrder(BiTree bt);         /*非递归前序遍历*/
void NRInOrder(BiTree bt);         /*非递归中序遍历*/
void Destroy (BiTree* bt);          /*销毁二叉树*/

void Visite(char c)
{
    printf("%c",c);
}


int main()  /*主函数*/
{
    BiTree bt;  
    printf("请输入数据\n");  
   Initiate(bt);  
  
    printf("\n前序遍历结果：\n");  
    PreOrder(bt);  
    printf("\n前序非递归遍历结果：\n");  
    NRPreOrder(bt);  
  
    printf("\n中序遍历结果：\n");  
    InOrder(bt);  
    printf("\n中序非递归遍历结果：\n");  
    NRInOrder(bt);  
  
    printf("\n后序遍历结果：\n");  
    PostOrder(bt);  
   
   
}  


Queue Init_Queue()
{
    Queue p=(Queue)malloc(sizeof (QueueNode));

    if (p==NULL)
    {
        puts("申请空间失败!");
        return NULL;
    }

    memset(p->s,0,sizeof(p->s));

    p->front=p->rear=0;

    return p;
}

void In_Queue(Queue q,BiTree bt)   /*入队*/
{
    if (Full_Queue(q))
        return ;

    ++q->rear;
    q->rear%=MAXSIZE;
    bt->data=q->s[q->rear];
}

void OutQueue(Queue q,BiTree* bt)       /*出队*/
{
    if (Empty_Queue(q))
        return ;

    ++q->front;
    q->front%=MAXSIZE;
    (*bt)->data=q->s[q->front];

}

int Empty_Queue(Queue q)         /*判断队列是否为空*/
{
    return q->front==q->rear;
}

void Destroy_Queue(Queue* q)       /*销毁队列*/
{
    if (*q)
        free(*q);

    *q=NULL;
}

int Full_Queue(Queue q)
{
    return q->front==q->rear+1;  /*判断是否队满*/
}
int  index=0;
char node[10];
int Initiate (BiTree bt)   /*初始化建立二叉树*bt的头结点*/
{   char ch;
ch = node[index++];
    scanf("%d",&bt);  
    if('#' == ch)  
     {  
       bt = NULL;  
     }  
    else{
        if((bt=(BiTNode*)malloc(sizeof(BiTNode)))==NULL)
            return 0;

     bt->lchild=NULL;
     bt->rchild=NULL;
     return 1;
    }
     
}
 
void PreOrder(BiTree bt)       /*先序遍历二叉树bt*/
{  
  if (bt==NULL)
      return;                  /*递归调用的结束条件*/

  Visite(bt->data);           /*访问结点的数据域*/

  PreOrder(bt->lchild);       /*先序递归遍历bt的左子树*/
  PreOrder(bt->rchild);       /*先序递归遍历bt的右子树*/  
}
void InOrder(BiTree bt)       /*中序遍历二叉树bt*/
{
  if (bt==NULL)              /*递归调用的结束条件*/
      return;      
         
  PreOrder(bt->lchild);      /*先序递归遍历bt的左子树*/

  Visite(bt->data);          /*访问结点的数据域*/

  PreOrder(bt->rchild);      /*先序递归遍历bt的右子树*/  
}
void PostOrder(BiTree bt)    /*后序遍历二叉树bt*/
{  
    if (bt==NULL)            /*递归调用的结束条件*/
        return;   

    PostOrder(bt->lchild);   /*后序递归遍历bt的左子树*/
    PostOrder(bt->rchild);   /*后序递归遍历bt的右子树*/  

    Visite(bt->data);        /*访问结点的数据域*/
}
void LevelOrder(BiTree bt)   /*层次遍历二叉树bt*/
{
    Queue q=Init_Queue();    /*队列初始化*/

    BiTree x=0;                 /*队列暂存数据*/

     if (bt==NULL)
         return;

        In_Queue(q,bt);          /*入队*/

      while(!Empty_Queue(q))     /*如果队列不为空*/
      {
          OutQueue(q,&x);                     /*取出队列数据*/
          Visite(x->data);                    /*访问队首结点的数据域*/
          if (x->lchild!=NULL)                /*将队首结点的左孩子结点入队列*/
               In_Queue(q, x->lchild);

          if (x->rchild!=NULL)                /*将队首结点的右孩子结点入队列*/
              In_Queue(q, x->rchild);
      }
         Destroy_Queue(&q);                  
}
void NRPreOrder(BiTree bt)   /*非递归先序遍历二叉树*/
{
    BiTree stack[MAXSIZE]={0};
    BiTree p=NULL;

    int top=0;

    if(bt==NULL)
        return;

    p=bt;

    while(!(p=NULL&&top==0))
    {
        while(p!=NULL)
        {
                  /*访问结点的数据域*/
            if(top<MAXNODE-1)     /*将当前指针p压栈*/
            {
                stack[top]=p;
                top++;
            }
            else
            {
                printf("栈溢出");
                return;
            }

            p=p->lchild;             /*指针指向p的左孩子*/
        }

        if(top<=0)
            return;       /*栈空时结束*/
        else
        {
            top--;
            Visite(p->data);
              p=stack[top];       /*从栈中弹出栈顶元素*/
            p=p->rchild;       /*指针指向p的右孩子结点*/
        }
    }
}
void NRInOrder(BiTree bt)   /*非递归中序遍历二叉树*/
{
    BiTree stack[MAXSIZE]={0};
    BiTree p=NULL;

    int top=0;

    if(bt==NULL)
        return;

    p=bt;

    while(!(p=NULL&&top==0))
    {
        while(p!=NULL)
        {
                  /*访问结点的数据域*/
            if(top<MAXNODE-1)     /*将当前指针p压栈*/
            {
                stack[top]=p;
                top++;
            }
            else
            {
                printf("栈溢出");
                return;
            }

            p=p->lchild;             /*指针指向p的左孩子*/
        }

        if(top<=0)
            return;       /*栈空时结束*/
        else
        {
            top--;
            p=stack[top];       /*从栈中弹出栈顶元素*/
            Visite(p->data);     
            p=p->rchild;       /*指针指向p的右孩子结点*/
        }
    }
}
void Destroy (BiTree *bt)
{
      if(*bt)
      {
           Destroy(&(*bt)->lchild);
           Destroy(&(*bt)->rchild);
           free(*bt);
      }
      *bt=NULL;
}

这回显示没错误但是不能运行

还有非递归的先序遍历和非递归中序遍历我调试了好久 也没搞出来

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE  1024
#define MAXNODE  1024
#define LEN sizeof (BiTree)

typedef struct BiTree
{

    int data;                //存放数据
    struct BiTree* left;     //左孩子
    struct BiTree* right;    //右孩子
}BiTree,*PBiTree;

void Creat_Tree(PBiTree* p);                     //创建二叉树
int Add_Tree(PBiTree* p,int data,int n,int m);   //输入数据
int Get_Height(PBiTree p);                       //获取深度

void Visit(PBiTree p);

void Pre_Order(PBiTree p);     //前序遍历
void In_Order(PBiTree p);      //中序遍历
void Post_Order(PBiTree p);    //后序遍历
void NRPre_Order(PBiTree p);
void Visit(PBiTree p);         //访问节点数据

void Del_Tree(PBiTree* p);     //释放树


int main()
{
    PBiTree p=NULL;
    int n=0;
    int i=0;
    int data=0;

    printf("请输入节点个数:");
    scanf("%d",&n);

    for (i=0;i!=n;++i)
    {
        printf("请输入第%d个节点的数据:",i+1);
        scanf("%d",&data);
        Add_Tree(&p,data,1,1);
    }

    printf("二叉树深度为%d:\n",Get_Height(p));

    puts("前序遍历结果为:");
    Pre_Order(p);
    puts("");

    puts("中序遍历结果为:");
    In_Order(p);
    puts("");

    puts("后序遍历结果为:");
    Post_Order(p);
    puts("");

    puts("非递归先序遍历结果为:");
    NRPre_Order(p);
    puts("");
   
    Del_Tree(&p);

    return 0;
}

void Creat_Tree(PBiTree* p)
{
    if ((*p=(PBiTree)malloc(LEN))==NULL)
    {
        puts("创建失败!");
        return ;
    }

    memset(*p,0,LEN);
}

int Add_Tree(PBiTree* p,int data,int n,int m)  //输入数据
{
    int k=0;

    if (n>m)
        return 0;

    if (*p==NULL)
    {
        Creat_Tree(p);
        (*p)->data=data;

        return 1;
    }

    if (!k)
        k=Add_Tree((&(*p)->left),data,n+1,m);

    if (!k)
        k=Add_Tree((&(*p)->right),data,n+1,m);

    while (!k&&n==1)
    {
        ++m;
        k=Add_Tree(p,data,n+1,m);
    }

    return k;
}


void Visit(PBiTree p)         //访问节点数据
{
    printf("%4d",p->data);
}

void Pre_Order(PBiTree p)     //先序遍历
{
    if (p==NULL)
        return ;

    Visit(p);

    Pre_Order(p->left);
    Pre_Order(p->right);
}

void In_Order(PBiTree p)      //中序遍历
{
    if (p==NULL)
        return ;

    In_Order(p->left);

    Visit(p);

    In_Order(p->right);
}
void Post_Order(PBiTree p)    //后序遍历
{
    if (p==NULL)
        return ;

    Post_Order(p->left);
    Post_Order(p->right);

    Visit(p);
}
void NRPre_Order(PBiTree p)   /*非递归先序遍历二叉树*/
{
    PBiTree stack[MAXNODE],t;
    int top;
    if(p==NULL)
    return;
    top=0;
    t=p;
    while(!(t==NULL&&top==0))
    {
        while(t!=NULL)
        {
            Visit(t->data);
            if(top<MAXNODE-1)
            {
                stack[top]=t;
                top++;
            }
            else {
                printf("栈溢出");
            
            return;
        }
        t=t->left;
        
    }
    if(top<=0)
    return;
    else{
        top--;
        t=stack[top];
        t=t->right;
    }
}
}
int Get_Height(PBiTree p)    //获取深度
{
    int l=0;   
    int r=0;  

    if (p==NULL)
        return 0;

    l=Get_Height(p->left)+1;
    r=Get_Height(p->right)+1;

    return l>r?l:r;
}

void Del_Tree(PBiTree* p)       //释放树
{
    if (*p==NULL)
        return ;

    Del_Tree(&((*p)->left));
    Del_Tree(&((*p)->right));

    free(*p);
    *p=NULL;
}