Tree Traversals Again

树3 Tree Traversals Again（25 分）
An inorder binary tree traversal can be implemented in a non-recursive way with a stack. For example, suppose that when a 6-node binary tree (with the keys numbered from 1 to 6) is traversed, the stack operations are: push(1); push(2); push(3); pop(); pop(); push(4); pop(); pop(); push(5); push(6); pop(); pop(). Then a unique binary tree (shown in Figure 1) can be generated from this sequence of operations. Your task is to give the postorder traversal sequence of this tree.

Figure 1
Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤30) which is the total number of nodes in a tree (and hence the nodes are numbered from 1 to N). Then 2N lines follow, each describes a stack operation in the format: “Push X” where X is the index of the node being pushed onto the stack; or “Pop” meaning to pop one node from the stack.

Output Specification:

For each test case, print the postorder traversal sequence of the corresponding tree in one line. A solution is guaranteed to exist. All the numbers must be separated by exactly one space, and there must be no extra space at the end of the line.

Sample Input:

6
Push 1
Push 2
Push 3
Pop
Pop
Push 4
Pop
Pop
Push 5
Push 6
Pop
Pop
Sample Output:

3 4 2 6 5 1

#include <stdio.h>
#include <stdlib.h>
#define MAX 30

typedef struct node//作为堆栈
{
    int data[MAX];
    int top;//末尾元素的下标
}Stack;

Stack* CreateStack()
{
    Stack* s;
    s = (Stack*)malloc(sizeof(Stack));
    s->top = -1;
    return s;
}

void Push(Stack* q, int x)
{
    q->data[++(q->top)] = x;
}

int Pop(Stack* q)
{
    return q->data[(q->top)--];
}

void Solve(int pre[], int in[], int post[], int prel, int inl, int postl, int length)
{//目的是以后序遍历的访问顺序存储在后序数组中
    int root, i, L, R;
    if(length == 0){
        return;
    }
    if(length == 1){
        post[postl] = pre[prel];
        return;
    }
    root = pre[prel];
    post[postl + length - 1] = root;
    for(i = 0; i < length; i++){
        if(in[inl + i] == root){
            break;
        }
    }
    L = i; //根节点左边个数
    R = length - i - 1;//根节点右边个数
    Solve(pre, in, post, prel + 1, inl, postl, L);
    Solve(pre, in, post, prel + L + 1, inl + L + 1, postl + L, R);
}

int main()
{
    Stack* q;
    char str[10];//用于循环接收每次的指令，是pop或是push
    int pre[30];//记录先序遍历时的访问顺序
    int in[30];//记录中序遍历时的访问顺序
    int post[30];//记录后序遍历时的访问顺序
    int N, i, x, a = 0, b = 0;

    q = CreateStack();
    scanf("%d", &N);
    for(i = 0; i < 2*N; i++){
        scanf("%s", str);
        if(str[1] == 'u'){
            scanf("%d", &x);
            pre[a++] = x;
            Push(q, x);
        }else{
            in[b++] = Pop(q);
        }
    }
    Solve(pre, in, post, 0, 0, 0, N);
    for(i = 0; i < N - 1; i++){
        printf("%d ", post[i]);
    }
    printf("%d\n", post[N - 1]);
    return 0;
}