二叉树的遍历，递归和非递归，求深度

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define MAX 100
#define type char
typedef struct node{
    type date;
    struct node *right,*left;
}TreeNode,*pTreeNode;


typedef struct Linknode
{
    pTreeNode ptn;
    struct Linknode * next;
}LinkNode,*LiStack;


void PreOrder(pTreeNode T);
void PreOrder_no2(pTreeNode T);
void InOrder(pTreeNode T);
void InOrder_no2(pTreeNode t);//
void PostOrder(pTreeNode T);
void PostOrder_no2(pTreeNode t);//非递归算法
int Depth(pTreeNode T);
pTreeNode CreatTree();

int main()
{
//    printf("Hello world!\n");
    printf("         a\n\n");
    printf("    b         c\n\n");
    printf("       d   e\n\n");
    TreeNode tree[5] ;


    tree[0].date = 'A';
    tree[1].date = 'B';
    tree[2].date = 'c';
    tree[3].date = 'd';
    tree[4].date = 'e';
    tree[0].left = &tree[1];
    tree[0].right = &tree[2];
    tree[1].left = NULL;
    tree[1].right = &tree[3];

    tree[2].left = &tree[4];
    tree[2].right = NULL;

    tree[3].left = NULL;
    tree[3].right = NULL;

    tree[4].left = NULL;
    tree[4].right = NULL;


//   tree = CreatTree();
    printf("PreOrder:");
    PreOrder_no2(tree);
    printf("\n");
    printf("InOrder:");
    InOrder_no2(tree);
//    InOrder(tree);
//    printf("\n");
    printf("PostOrder:");
    PostOrder_no2(tree);
//    printf("\n");


//    printf("the depth of tree:%d",Depth(tree));


    return 0;
}
int Depth(pTreeNode T)
{
    int dl,dr,max;
 //   max = 0;
    if(NULL != T)
    {
        dl = Depth(T->left);
        dr = Depth(T->right);
        max = dl>dr?dl:dr;
        return (max+1);
    }else
    {
        return 0;
    }

}

void PostOrder(pTreeNode T)
{
    if(NULL != T)
    {
        if(NULL != T->right)
        PostOrder(T->right);
        printf("%c\t",T->date);
        if(NULL != T->left)
        PostOrder(T->left);
    }
}

//写栈的代码，是关于指针的，不能使用！
void InitStack(LiStack S)
{
    S = NULL;
}
bool IsEmpty(LiStack s)
{
    return (s==NULL);
}
void Push(LiStack s,pTreeNode * pt)
{
    LiStack p = (LiStack)malloc( sizeof(LinkNode));
    p->ptn = *pt;
    p->next = s;
    s = p;
}
bool Pop(LiStack s,pTreeNode * pt)
{
    LiStack p;
    if(NULL == s) return false;
    else{
        p= s;
        *pt = p->ptn;
        s=s->next;
        free(p);
        return true;
    }

}

void InOrder_no(pTreeNode t)
{
    LiStack S;
    InitStack(S);//初始化堆栈
    pTreeNode p = t ;
    while(p || !IsEmpty(S))//节点不为空或者栈为不为空，都将继续循环
    {
        if(p)
        {
            Push(S,&p);//将根节点入栈
            p = p->left;//再将左子树入栈
        }
        else
        {
            Pop(S,&p);//将指针退栈，访问根节点，遍历右子数
            printf("%c ",p->date);
            p = p->right;
        }
    }
}
void PreOrder_no2(pTreeNode t)
{
    pTreeNode ptn[MAX];
    int top = -1;
    pTreeNode p = t;
    while(p || (-1 != top))
    {
        if(p)
        {
            printf("%c ",p->date);
            ptn[++top] = p;//将根节点入栈
            p = p->left;//将左节点入栈
        }else
        {
            p = ptn[top--];//出栈
            p = p->right;
        }
    }
}

/**********************************************/
/**
    后序遍历的非递归算法很精彩，有点难以理解
    但是非常漂亮。
***********************************************/
void PostOrder_no2(pTreeNode t)
{
    pTreeNode ptn[MAX];
    int tag[MAX];//这个很重要的。
    int top = -1;
    pTreeNode p = t;
    while(p || (-1 != top))
    {
        while(p)//将根节点和左子树全部入栈
        {
            ptn[++top] = p;//将根节点入栈
            tag[top] = 0;//
            p = p->left;//将左节点入栈
        }

        while(top != -1 && tag[top]== 1)//打印出栈的序列
        {
            p = ptn[top--];//出栈
            printf("%c ",p->date);
        }

        if(top  != -1)
        {
            tag[top]=1;
            p = ptn[top]->right;
        }
        else break;
    }

}
void InOrder_no2(pTreeNode t)//中序遍历,非递归算法
{
    pTreeNode ptn[MAX];//初始化栈
    int top = -1;
    pTreeNode p = t;
    while(p || (-1 != top))
    {
        if(p)
        {
            ptn[++top] = p;//将根节点入栈
            p = p->left;//将左节点入栈
        }else
        {
            p = ptn[top--];//出栈
            printf("%c ",p->date);//
            p = p->right;
        }
    }
}


void InOrder(pTreeNode T)
{
    if(NULL != T)
    {
        if(NULL != T->left)
        InOrder(T->left);
        printf("%c\t",T->date);
        if(NULL != T->right)
        InOrder(T->right);
    }
}

pTreeNode CreatTree()
{
    pTreeNode T;
    type ch;
    printf("please input the character :\n");
    scanf("%c",&ch);
//    ch = getchar();
    fflush(stdin);//必须注意刷新缓冲区，才行
    if('#'== ch) T = NULL;
    else
    {
        T =(pTreeNode)malloc(sizeof(TreeNode));
        T->date = ch;
        printf("left node:\n");
        T->left = CreatTree();
        printf("right node:\n");
        T->right = CreatTree();
    }
    return T;
}

void PreOrder(pTreeNode T)
{
  if(NULL != T)
  {
      printf("%c",T->date);
      if(NULL != T->left)
      PreOrder(T->left);
      if(NULL != T->right)
      PreOrder(T->right);
  }
}