03-树3 Tree Traversals Again

 

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

//Push的顺序是先序遍历的顺序，Pop的顺序的中序遍历的顺序
//三个序列中，知道中序和随意另一个，即可确定一棵树 
#include<stdio.h> 
#include<stdlib.h>
#define null -1

struct SNode{
    int *Data;
    int Top;
    int Maxsize; 
};
typedef struct SNode *stack;

//建空堆栈 
stack BuildStack(int n){
    stack S = (stack)malloc(sizeof(struct SNode));
    S->Data = (int*)malloc(sizeof(int)*n);
    S->Top = null;
    S->Maxsize = n;
    return S;
} 

//判断堆栈是否满 
bool IsFull(stack S){
    return S->Top == S->Maxsize-1;
}

//将元素入栈 
void Push(stack S, int data){
    if(!IsFull(S)){
        S->Data[++(S->Top)] = data;
    }
}

//将元素出栈，没有写判断栈空的函数，这题不会超出堆栈范围的，其实判断栈满的函数也不用写(当然这样的习惯不好🤐)
int Pop(stack S){
    return S->Data[(S->Top--)];
}

//递归求后序序列 
void Posttraversal(int *pre, int *mid, int root, int left, int right) {
     //root是pre中根节点的位置，left、right是这段序列在mid中的范围 
     //这段写的很难看，可是我也不知道怎么改好一点，我知道了会回来改的🙃 
    if(left>right){                   
        return;
    }
    else if(left==right){            
        printf("%d ", mid[left]);
        return;
    }
    int i, L=0;
    for(i=left; i<=right; i++){        //在mid中找到根的位置，以此确定左右子树 
        if(mid[i]==pre[root]){
            break;
        }
    }
    L = i-left;      //求出左子树的个数，用这个去求递归右子树时pre中根节点的位置，将左子树为空的情况考虑进去 
    Posttraversal(pre, mid, root+1, left, i-1);       //递归遍历左子树 
    Posttraversal(pre, mid, root+L+1, i+1, right);    //递归遍历右子树 
    if(root == 0) 
        printf("%d\n", pre[0]);         //后序序列整棵树的根结点在最后，单独拿出来处理格式 
    else 
        printf("%d ", pre[root]);      
}

int main( ){
    int N;
    scanf("%d", &N);
    int data, pre[N], mid[N];
    stack S = BuildStack(N);
    for(int i=0, j=0, k=0; i<2*N; i++){
        char c, str[5];
        scanf("\n");
        for(int m=0; m<5; m++){
            scanf("%c", &c);
            if(c=='\n')
                break;
            else str[m] = c;
        }
        if(str[1]=='u'){
            scanf("%d", &data);
            pre[j++] = data;
            Push(S, data);
        }
        else if(str[1]=='o'){
            mid[k++] = Pop(S);
        }
    }
//    for(int i=0; i<N; i++) {
//        printf("%d %d\n", pre[i], mid[i]);
//    }
    if(N==1) 
        printf("%d\n", pre[0]);
    else
        Posttraversal(pre, mid, 0, 0, N-1);
    return 0;
}