03-树3 Tree Traversals Again(C)

 日常，25分，还有一个13分的错误。

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

 

 这一个才13分问题：

花费我两天时间，后来在csdn上发现只是一个前，中序变为后序输出的问题，也找到了解决方法，那是一个极其巧妙的递归，下面是我第一个AC,

试点	提示	内存(KB)	用时(ms)	结果	得分
0	sample 有单边有双边结点	372	1	答案正确	12 / 12
1	单边喇叭张开形	188	1	答案错误	0 / 4
2	交错	372	1	答案错误	0 / 4
3	N=1	368	1	答案正确	1 / 1
4	N=30，复杂组合	184	1	答案错误	0 / 4

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct TNode* BinTree;
typedef BinTree TR;
struct TNode{
	int data;
	BinTree left;
	BinTree right;
};

BinTree Build_Tree(int num);
void Move_rear(TR *rear, TR Tree);
void Add_det(TR *rear, int data, TR *Tree);
BinTree Creat_tree(int data);
BinTree Search_data(BinTree rear, BinTree Tree);
void PostReverse_print(BinTree Tree, int post);

int main(){
	int num, post;
	TR tree;
	scanf("%d", &num);
	tree = Build_Tree(num);
	post = tree ->data;
	PostReverse_print(tree, post);
	return 0;
}
BinTree Build_Tree(int num)
{
	TR Tree, rear;
	char str[10];
	int data, sign = 0;
	Tree = NULL;
	rear = NULL;
	for(int i = 0; i < 2 * num; i++){
		scanf("%9s", str);
		if(!strcmp(str, "Push")){
			scanf("%d", &data);
			Add_det(&rear, data, &Tree);

		}else if(!strcmp(str, "Pop")){
			sign++;
			if(sign == 2){
				Move_rear(&rear, Tree);
				sign = 0;
			}
		}
	}
	return Tree;
}
void Add_det(TR *rear, int data, TR *Tree)
{
	TR PtrL;
	if(!(*Tree)){
		(*Tree) = Creat_tree(data);
		(*rear) = (*Tree);
		return ;
	}
	if(!((*rear) ->left)){
		PtrL = Creat_tree(data);
		(*rear) ->left = PtrL;
		*rear = PtrL;
	}else{
		PtrL = Creat_tree(data);
		(*rear) ->right = PtrL;
		*rear = PtrL;
	}
}
BinTree Creat_tree(int data)
{
	TR PtrL;
	PtrL = (BinTree)malloc(sizeof(struct TNode));
	PtrL ->data = data;
	PtrL ->left = NULL;
	PtrL ->right = 	NULL;
	return PtrL;
}
void Move_rear(TR *rear, TR Tree)
{
	TR Temp;
	Temp = (*rear);
	if(!Tree){
		return ;
	}
	*rear = Search_data((*rear), Tree);
	if((*rear) ->right == Temp){
		*rear = Search_data((*rear), Tree);
	}
}
BinTree Search_data(BinTree rear, BinTree Tree)
{
	TR found;
	if (Tree == NULL || rear == NULL) {
        return NULL;
    }
    if (Tree == rear) {
        return NULL;
    }
    if (Tree->left == rear || Tree->right == rear) {
        return Tree;
    }
    found = Search_data(rear, Tree->left);
    if (found != NULL) {
        return found;
    }
    return Search_data(rear, Tree->right);
}
void PostReverse_print(BinTree Tree, int post)
{
	if(Tree){
		PostReverse_print(Tree ->left, post);
		PostReverse_print(Tree ->right, post);
		if(Tree ->data != post){
			printf("%d ", Tree ->data);
		}else{
			printf("%d", Tree ->data);
		}
	}
}

接下来，便在csdn上找了一些，发现了这样的思路，通过透出，先，中序的值数组，推出完整树，在后序输出，下面便是我的AC代码，

这是运行结果

测试点	提示	内存(KB)	用时(ms)	结果	得分
0	sample 有单边有双边结点	316	1	答案正确	12 / 12
1	单边喇叭张开形	176	1	答案正确	4 / 4
2	交错	180	1	答案正确	4 / 4
3	N=1	348	1	答案正确	1 / 1
4	N=30，复杂组合	176	1	答案正确	4 / 4

 关键方法为，果然，递归说难也难，想不到规律，便无法可依靠

BinTree Build_Tree(int num, int *a, int *b)
{
	TR Tree;
	int i;
	if (num == 0)
		return NULL;
	Tree = Creat_tree(a[0]);
	for (i = 0; i < num; i++) 
	{
		if (a[0] == b[i])
			break;
	}
	int Left = i;  
 	int Right = num - (i + 1);  
	Tree ->left = Build_Tree(Left, a + 1, b);
    Tree ->right = Build_Tree(Right, a + Left + 1, b + Left + 1);
	return Tree;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct TNode* BinTree;
typedef struct SNode* Stack;
typedef BinTree TR;
struct TNode{
	int data;
	BinTree left;
	BinTree right;
};
struct SNode{
	int data;
	struct SNode *Next;
};

BinTree Build_Tree(int num, int *a, int *b);
BinTree Creat_tree(int data);
void Init_array(int **a, int **b, int num);
void PostReverse_print(BinTree Tree, int post);
void Push_Stack(int num, Stack S);
int Pop_Stack(Stack S);
int IsEmpty_Stack(Stack S);
Stack Creat_Stack();

int main(){
	int num, post;
	TR Tree;
	Stack S;
	int *Pre, *Ino;
	scanf("%d", &num);
	Init_array(&Pre, &Ino, num);
	Tree = Build_Tree(num, Pre, Ino);
	PostReverse_print(Tree, Pre[0]);
	free(Pre);
	free(Ino);
	free(S);
	return 0;
}
BinTree Build_Tree(int num, int *a, int *b)
{
	TR Tree;
	int i;
	if (num == 0)
		return NULL;
	Tree = Creat_tree(a[0]);
	for (i = 0; i < num; i++) 
	{
		if (a[0] == b[i])
			break;
	}
	int Left = i;  
 	int Right = num - (i + 1);  
	Tree ->left = Build_Tree(Left, a + 1, b);
    Tree ->right = Build_Tree(Right, a + Left + 1, b + Left + 1);
	return Tree;
}
BinTree Creat_tree(int data)
{
	TR PtrL;
	PtrL = (BinTree)malloc(sizeof(struct TNode));
	PtrL ->data = data;
	PtrL ->left = NULL;
	PtrL ->right = 	NULL;
	return PtrL;
}
void Init_array(int **a, int **b, int num)
{
	int data, p_t = 0, i_t = 0;
	char str[10];
	Stack S;
	S = Creat_Stack();
	*a = (int *)malloc(sizeof(int) * num);
	*b = (int *)malloc(sizeof(int) * num);
	for(int i = 0; i < 2 * num; i++){
		scanf("%9s", str);
		if(!strcmp(str, "Push")){
			scanf("%d", &data);
			(*a)[p_t++] = data; 
			Push_Stack(data, S);
		}else if(!strcmp(str, "Pop")){
			if(IsEmpty_Stack(S)){
				return ;
			}
			(*b)[i_t++] = Pop_Stack(S);
		}
	}
}
void PostReverse_print(BinTree Tree, int post)
{
	if(Tree){
		PostReverse_print(Tree ->left, post);
		PostReverse_print(Tree ->right, post);
		if(Tree ->data != post){
			printf("%d ", Tree ->data);
		}else{
			printf("%d", Tree ->data);
		}
	}
}
Stack Creat_Stack()
{
	Stack PtrL;
	PtrL = (Stack)malloc(sizeof(struct SNode));
	PtrL ->Next = NULL;
	return PtrL;
}
void Push_Stack(int num, Stack S)
{
	Stack PtrL;
	PtrL = (Stack)malloc(sizeof(struct SNode));
	PtrL ->data = num;
	PtrL ->Next = S ->Next;
	S ->Next = PtrL;
}
int Pop_Stack(Stack S)
{
	Stack Temp;
	int top;
	if(IsEmpty_Stack(S)){
		printf("It is FULL Stack!\n");
		return -1;
	}else{
		Temp = S ->Next;
		S ->Next = Temp ->Next;
		top = Temp ->data;
		free(Temp);
		return top;
	}
}
int IsEmpty_Stack(Stack S)
{
	return (S ->Next == NULL);
}