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.
给你一棵树的中序非递归操作，求它的后序遍历结果。

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.
第一行为一个正数n，小于等于30。之后2*n行为非递归实现中序遍历的操作。

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

思路分析

关键在于知道，中序遍历的非递归操作中的压栈操作序列就是先序遍历的结果。因为中序遍历总要先把根节点压栈，先去访问左子树。因此不论建树还是不建树，解法都大同小异，都可以用递归去实现。
先序遍历：1 2 3 4 5 6
中序遍历：3 2 4 1 6 5
后序遍历：3 4 2 6 5 1

1	2	3	4	5	6
			1
					1

首先从先序遍历结果中找到根
再从中序遍历找到根的位置，确定左右子树的结点个数l和r
将这个根结点插入到后序遍历结果数组中，若是右子树上的结点，插到比左子树上的结点多l的位置上。

C语言代码

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

typedef struct stack
{
    int data[2*maximum+1];
    int top;
}stack;

stack s;
/*分别存储先序遍历结果，中序遍历结果和后续遍历结果*/
int inorder[maximum + 1], preorder[maximum + 1], result[maximum + 1];

void init(stack *s)
{
    s->top = 0;
}

void push(stack *s, int x)
{
    s->data[s->top++] = x;
}

int pop(stack *s)
{
    return s->data[--s->top];
}

void postorder(int prel, int inl, int posl, int n)
{
    int root;
    if (n == 0) return;//递归出口
    result[posl + n - 1] = preorder[prel];
    root = preorder[prel];//根据前序遍历找到根
    int l = 0, r;
    /*根据在先序遍历中找到的根来确定根在中序遍历中的位置，
    从而确定左右子树结点的个数*/
    while (l < n)
    {
        if (root == inorder[inl + l]) break;
        l++;
    }
    r = n - l - 1;
    postorder(prel + 1, inl, posl, l);
    postorder(prel + l + 1, inl + l + 1, posl + l, r);
}

int main()
{
    int n, i, x, t = 0, k = 0;
    char str[8];
    scanf("%d", &n);
    getchar();
    for (i = 0; i < 2 * n; i++)
    {
        gets(str);
        if (str[1] == 'o') inorder[t++] = pop(&s);
        else
        {
            if (str[6] >='0' && str[6] <= '9') x = (str[5] - '0') * 10 + str[6] - '0';
            else x = str[5] - '0';
            push(&s, x);
            preorder[k++] = x;
        }
    }
    postorder(0, 0, 0, n);
    for (i = 0; i < t - 1; i++) printf("%d ", result[i]);
    printf("%d", result[t - 1]);
    return 0;
}