#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
#define MAX 100
typedef struct node* tree_pointer;
typedef struct node{
    char data;
    tree_pointer left_child,right_child;
}BiTree;
void CreateBiTree(BiTree **root);
void PreOrder(BiTree *root);
void
 
 InOrder(BiTree *root);
void PostOrder(BiTree *root);
void OPreOrder(BiTree *root);
void OInOrder(BiTree *root);
void OPostOrder(BiTree *root);
BiTree *STACK[MAX];
void push(int *top,BiTree *ptr);
BiTree *pop(int *top);
BiTree *Top(int top);
void treeshape(BiTree *root,int n);
int leaf(BiTree *root);
void
 
 treeheight(BiTree *root,int h);
int depth = 0;
int main()
{
    BiTree *root;//這裡是一個指標，才能不把地址固定，進而可以進行malloc操作
    printf("請根據先序輸入資料\n");
    CreateBiTree(&root);//只有二重指標才可以改值
    putchar('\n');
    while(1)
    {
        printf("1、先序遍歷  2、中序便利 3、後序遍歷\n \
4、先序遞迴 5、中序遞迴 6、後序遞迴\n \
7、列印樹狀 8、列印葉子節點數 9、列印樹高度\n"
 
);
        printf("輸入-1退出\n");
        int num;
        scanf(" %d",&num);
        if(num == -1)
            break;
        switch(num)
        {
            case 1:
                PreOrder(root);
                putchar('\n');
                break;
            case 2:InOrder(root);
                putchar('\n');
                break;
            case 3:PostOrder(root);
                putchar('\n');
                break;
            case 4:
                memset(STACK,0,sizeof(STACK));
                OPreOrder(root);
                putchar('\n');
                break;
            case 5:memset(STACK,0,sizeof(STACK));
                OInOrder(root);
                putchar('\n');
                break;
            case 6:memset(STACK,0,sizeof(STACK));
                OPostOrder(root);
                putchar('\n');
                break;
            case 7:
                treeshape(root,1);
                putchar('\n');
                break;
            case 8:
                printf("\n葉子結點為：%d\n",leaf(root));
                break;
            case 9:
                treeheight(root,0);
                printf("樹的高度為 %d\n",depth);
        }
    }
    return 0;

}
void CreateBiTree(BiTree **root)
{
    char ch;
    scanf(" %c",&ch);
    if(ch == '#') 
        *root = NULL;
    else 
    {
        *root = (BiTree*)malloc(sizeof(BiTree));
        (*root)->data = ch;
        CreateBiTree(&((*root)->left_child));
        CreateBiTree(&((*root)->right_child));
    }

}
void PreOrder(BiTree *root)
{
    if(root)
    {
        printf("%c ",root->data);
        PreOrder(root->left_child);
        PreOrder(root->right_child);
    }
}
void InOrder(BiTree *root)
{
    if(root)
    {
        InOrder(root->left_child);
        printf("%c ",root->data);
        InOrder(root->right_child);
    }
}
void PostOrder(BiTree *root)
{
    if(root)
    {
        PostOrder(root->left_child);
        PostOrder(root->right_child);
        printf("%c ",root->data);
    }
}
void push(int *top,BiTree *ptr)
{
    if(*top == MAX-1)
    {
        printf("stack full\n");
        return;
    }
    else 
        STACK[++(*top)] = ptr;//因為從-1，所以下一個元素0開始，所以先++
                            //0 開始，後++

}
BiTree *pop(int *top)
{
    if(*top == -1)
    {
        printf("stack empty\n");
        return NULL;
    }
    else 
    {
        return STACK[(*top)--];//-1開始 從本元素減，所以後--;
                                //0開始，前--
    }

}

void OPreOrder(BiTree *root)
{
    int top = -1;//從個元素加起
    BiTree *p = root;
    while(p!=NULL || top!=-1)
    {
        while(p!=NULL)
        {
            printf("%c ",p->data);
            push(&top,p);
            p = p->left_child;
        }
        if(top!=-1)
        {
            p = pop(&top);
            p = p->right_child;
        }

    }
}
void OInOrder(BiTree *root)
{
    int top = -1;//從0個元素加起
    BiTree *p = root;
    while(p!=NULL || top!=-1)
    {
        while(p!=NULL)
        {
            push(&top,p);
            p = p->left_child;
        }
        if(top!=-1)
        {
            p = pop(&top);
            printf("%c ",p->data);
            p = p->right_child;
        }
    }
}
void OPostOrder(BiTree *root)
{
    int top = -1;//從0個元素加起
    BiTree *p = root;
    BiTree *q = NULL;
    while(p!=NULL || top!=-1)
    {
        while(p!=NULL)//先遍歷左邊
        {
            push(&top,p);
            p = p->left_child;
        }
        if(top!=-1)
        {
           p = Top(top);//獲得棧頂元素
           if((p->right_child == NULL) || p->right_child == q)//如果右邊為空，或者右邊訪問過，就輸出
            //切記，不能寫判斷左邊和右邊為空，如果那樣寫，就會進入死迴圈，永遠不能輸出
           {
               p = pop(&top);
               printf("%c ",p->data);
               q = p;//記下上一步做過的點
               p =NULL;//將當前點設為空，就可以跳過開頭while迴圈
           }
           else 
           {
                p = p->right_child;
           }
        }

    }
}
BiTree *Top(int top)
{
     return STACK[top];
}
void treeshape(BiTree *root,int n)//獲得樹的形狀
{
    if (root == NULL) 
        return ;
    treeshape(root->right_child,n+1);
    for(int i=0;i<n;i++)
        printf("   ");
    printf("%c\n",root->data);
    treeshape(root->left_child,n+1);

}
int leaf(BiTree *root)//獲得葉子節點個數
{
    int left,right;
    if(root == NULL)
        return 0;
    if(root->left_child == NULL && root->right_child == NULL)
        return 1;
    left = leaf(root->left_child);
    right = leaf(root->right_child);
    return left + right;

}
void treeheight(BiTree *root,int h)//獲得樹的高度，放在全域性變數depth裡面
{
    if(root)
    {
        if(h > depth)
            depth =h;
        treeheight(root->left_child,h+1);
        treeheight(root->right_child,h+1);
    }
}