一个二叉树的简单问题

代码在pta运行就是答案错误，但是在devc++运行的结果和给的例子一模一样，为什么啊？
求解释，感谢！

void menu1()
{
    printf("I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > ");   
}
void menu2()
{
    printf("1-先序 2-中序 3-后序 0-返回 > ");
}
void menu3()
{
    printf("1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > ");
}
typedef struct S
{
    char data;
    struct S* left;
    struct S* right;
} BT;
void creat(BT* * Bt)
{
    char ch;
    scanf("%c",&ch);
    if(ch=='#')
    {
       *Bt=NULL;
    }
    else
    {
        *Bt = (BT*)malloc(sizeof(BT));
        (*Bt) ->data = ch;
        creat(&((*Bt)->left));
        creat(&((*Bt)->right));
    }
    return;
}
void xianxu(BT* t)
{
    if(t)
    {
        printf("%c",t->data);
    xianxu(t->left);
    xianxu(t->right);
    }
}
void zhongxu(BT* t)
{
    if(t)
    {
        zhongxu(t->left);
    printf("%c",t->data);
    zhongxu(t->right);
    }
}
void houxu(BT* t)
{
    if(t)
    {
        houxu(t->left);
    houxu(t->right);
     printf("%c",t->data);
    }
}
void bianli(BT* t)
{
    printf("遍历\n");
    menu2();
    int input;
    scanf("%d",&input);
    getchar();
    switch(input)
    {
        case 1 :
            printf("先序遍历: ");
            xianxu(t);
            printf("\n");
            break;
        case 2:
             printf("中序遍历: ");
            zhongxu(t); printf("\n");
            break;
        case 3:
             printf("后序遍历: ");
            houxu(t); printf("\n");
            break;
        case 0:
            break;
        default:
            printf("不正确的遍历选项!\n");
            break;
    }
}
int NUM1(BT*t)
{   int count = 0;
    if(t==NULL)
    return 0;
      count = NUM1(t->left)+NUM1(t->right)+1;
 return count;
}
int NUM2(BT* T)
{
  if(T==NULL)
    {
        return 0;
    }
    int sum =0;
    if(T->left==NULL&&T->right==NULL)
    {
        sum++;
    }
   int a = NUM2(T->left );
    sum+=a;
    int b =       NUM2(T->right);
    sum+=b;
    return sum;
}
int deep(BT*t)
{
    int m,n;
    if(t==NULL)
    {
        return 0;
    }
    else
    {
        m = deep(t->left);
        n = deep(t->right);
        if(m>n)
            return (m+1);
        else
            return (n+1);
    }
}
void shuju(BT*t)
{
    printf("数据\n");
    menu3();
    int input;
    int sum1,sum2,sum3,sum4;
    scanf("%d",&input);
    getchar();
    switch(input)
    {
            case 1:
       sum1 = NUM1(t);
     printf("结点数: %d\n",sum1);
    break;
     case 2:
     sum2 = NUM2(t);
    printf("叶子结点数: %d\n",sum2);
    break;
     case 3:
    sum3 = NUM1(t) - NUM2(t);
    printf("分枝结点数: %d\n",sum3);
    break;
     case 4:
    sum4 = deep(t);
    printf("深度: %d\n",sum4);
    break;
     case 0:
    break;
     default :
    printf("不正确的数据选项!\n");
    break;
    }
    
}
void qingkong(BT**t)
{
   if(*t)
   {
        qingkong(&((*t)->left));
    qingkong(&((*t)->right));
    free(*t);
    *t = NULL;
   }
}

 void shuchu1( BT *t, int layer)
{
    int k = layer;
    if(t)
    {
        shuchu1(t->right, layer + 2);
        while(--k) putchar(' ');
        putchar(t->data);
        putchar('\n');
        shuchu1(t->left, layer + 2);
    }
} 
void shuchu( BT *t)
{
    shuchu1(t, 1);
}



int main()
{
   
    char input;
    BT* T=NULL;
    do
    {     menu1();
        scanf("%c",&input);
        getchar();
     switch(input)
     {
         case 'I' :
         case 'i' :
             printf("输入: ");
          creat(&T);
          getchar();
           break;
             
             case 'O' :
         case 'o' :
             printf("输出: \n");
             shuchu(T);
           break;
             
             case 'C' :
         case 'c' :
             qingkong(&T);
             printf("清空\n");
           break;
             
             case 'T' :
         case 't' :
           
             bianli(T);
           break;
             
             case 'D' :
         case 'd' :
             shuju(T);
           break;
              case 'q' :
         case 'Q' :
           break;
           default :
             printf("不正确的操作选项!\n");
       }
    }while(input!='Q'&&input!='q');
    
}


```c
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > x
不正确的操作选项!
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > I
输入: EIBJ##H###DF#A##G#C##
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > o
输出:
      C
    G
  D
      A
    F
E
  I
      H
    B
      J
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > t
遍历
1-先序 2-中序 3-后序 0-返回 > 9
不正确的遍历选项!
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > T
遍历
1-先序 2-中序 3-后序 0-返回 > 0
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > t
遍历
1-先序 2-中序 3-后序 0-返回 > 1
先序遍历: EIBJHDFAGC
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > T
遍历
1-先序 2-中序 3-后序 0-返回 > 2
中序遍历: JBHIEFADGC
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > t
遍历
1-先序 2-中序 3-后序 0-返回 > 3
后序遍历: JHBIAFCGDE
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 9
不正确的数据选项!
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > D
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 0
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 1
结点数: 10
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > D
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 2
叶子结点数: 4
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 3
分枝结点数: 6
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 4
深度: 4
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > c
清空
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > O
输出:
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 1
结点数: 0
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > i
输入: ABD##E##CF##G##
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > o
输出:
    G
  C
    F
A
    E
  B
    D
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 1
结点数: 7
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > Q

• 你可以参考下这篇文章：二叉树遍历的一些简单应用