03-树3 Tree Traversals Again

　　这道题我的思路是先根据输入得到先序和中序遍历的序列，最后用递归方式构造好树并进行遍历输出。事实上仅该题要求而言无需构造出二叉树再对树本身进行遍历，只需要知道先序和中序的序列，根据关系递归找出后序序列即可，网上方法也多是这种。而我当时一心想着就要用已知的两个序列把这颗树完全构建出来，才有了如下方法：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MaxSize 30
#define STR_LEN 5

typedef struct TreeNode *BinTree;
struct TreeNode{
    int Data;
    BinTree Left;
    BinTree Right;
};

typedef struct SNode *Stack;
struct SNode{
    int Data[MaxSize];
    int Top;
    int Cap;  //capability
};

int InOrder[MaxSize], PreOrder[MaxSize];

void Push(int data, Stack PtrS)
{
    if(PtrS->Top == PtrS->Cap - 1)
        return;
    else{
        PtrS->Data[++(PtrS->Top)] = data;
        return;
    }
}

int Pop(Stack PtrS)
{
    if(PtrS->Top == -1)
        return -1;
    else
        return PtrS->Data[(PtrS->Top)--];
}

void GetTwoOrders(int N)
{
    char oper[STR_LEN];
    Stack S;
    S = (Stack)malloc(sizeof(struct SNode));
    S->Top = -1;
    S->Cap = MaxSize;
    int i, data, j = 0, k = 0;
    for(i = 0; i < 2 * N; i++){
        scanf("%s", &oper);
        if(strcmp(oper, "Push") == 0){
            scanf("%d", &data);
            PreOrder[k++] = data;
            Push(data, S);
        }
        else{
            InOrder[j] = Pop(S);
            j++;
        }
    }
    return;
}

BinTree BuildTree(int *PreOrder, int pl, int pr,
                 int *InOrder, int il, int ir)
{
    int j, k, nN;
    BinTree Root;
    Root = (BinTree)malloc(sizeof(struct TreeNode));
//每一层新传进来，都让两个order从0到N，这样就得用两个新的order
    nN = ir - il;
    int newPreOrder[MaxSize], newInOrder[MaxSize];
    for(j = 0; j < nN; j++)
        newPreOrder[j] = PreOrder[j + pl];
    for(j = 0; j < nN; j++)
        newInOrder[j] = InOrder[j + il];
    int RootIndex;
    for(k = 0; k < nN; k++){
        if(newInOrder[k] == newPreOrder[0]){
            RootIndex = k;
            break;
        }
    }
    Root->Data = newPreOrder[0];
    if(nN == 1){
        Root->Left = NULL;
        Root->Right = NULL;
    }else if(nN == 0){
        return NULL;
    }else{
        int lpl, lpr, rpl, rpr, lil, lir, ril, rir;
    //means (left or right)side (pre or in)order (left or right)limit Index
        lil = 0;
        lir = RootIndex;
        lpl = 1;
        lpr = lpl + (lir - lil);
        ril = RootIndex + 1;
        rir = nN;
        rpl = ril;
        rpr = nN;
        Root->Left = BuildTree(newPreOrder, lpl, lpr, newInOrder, lil, lir);
        Root->Right = BuildTree(newPreOrder, rpl, rpr, newInOrder, ril, rir);
    }
    return Root;
}

int count = 1;

int PostOrderTraversal(BinTree BT, int count)
{
    if(BT){
        count = PostOrderTraversal(BT->Left, count);
        count = PostOrderTraversal(BT->Right, count);
        if(count == 1){
            printf("%d", BT->Data);
            count++;
        }
        else
            printf(" %d", BT->Data);
    }
    return count;
}

int main(int argc, char const *argv[])
{
    int N, i;
    BinTree T;
    T = (BinTree)malloc(sizeof(struct TreeNode));
    scanf("%d
", &N);
    int pl, pr, il, ir;
    GetTwoOrders(N);
    pl = 0;
    pr = N;
    il = 0;
    ir = N;
    T = BuildTree(PreOrder, pl, pr, InOrder, il, ir);
    count = PostOrderTraversal(T, count);
    printf("
");
    return 0;
}

　　构造树的主要思想是，对传入的已知PreOrder与InOrder序列找到根节点后进行左右子树拆分、链接两边后再递归此过程（101 - 102行），直到链接至叶节点。其中如何正确操作每次传入的两个序列是重点，考虑到树高度较大时找出某一具体子树的元素在序列中的位置情况复杂，我将每次传入的两个序列重新赋值到新的序列上（newPreOrder与newInOrder，70 - 76行），这样之后都可以对新的、只有单一情况（同最原始情况）的序列进行操作，过程更为清晰。

　　另外需要注意对题意的理解，PreOrder的确认并不应该直接顺序赋值，应和InOrder一样借助堆栈进行操作。