二叉树之遍历问题——根据先序中序遍历序列求后序序列

基础补充：二叉树的遍历：

简单的方法是递归实现，非递归麻烦些。
先序遍历，访问当前值，访问左节点，访问右节点；
中序遍历，访问左节点，访问当前值，访问右节点；
后序遍历，访问左节点，访问右节点，访问当前值；
非递归的方法，需要自己维护一个栈。

题意：给出二叉树的先序和中序遍历序列，输出其后序遍历序列

思路：构造递归函数，Create(char *pre,char *in);pre、in分别表示先序遍历序列和中序序列，则先序序列的首元素为树的根结点，

在中序序列中找出此根结点的下标，将其分为左右两个序列，即为根结点的左右子树的中序遍历序列，同样根据分出的左右子树的长度可以将

先序遍历序列拆分成左右子树的先序遍历序列，然后进行递归......

例题如下：（附代码）

1、 http://acm.pku.edu.cn/JudgeOnline/problem?id=2255

Tree Recovery

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 4025		Accepted: 2699

Description

Little Valentine liked playing with binary trees very much. Her favorite game was constructing randomly looking binary trees with capital letters in the nodes.
This is an example of one of her creations:

                                               D

                                              / /

                                             /   /

                                            B     E

                                           / /     /

                                          /   /     /

                                         A     C     G

                                                    /

                                                   /

                                                  F

To record her trees for future generations, she wrote down two strings for each tree: a preorder traversal (root, left subtree, right subtree) and an inorder traversal (left subtree, root, right subtree). For the tree drawn above the preorder traversal is DBACEGF and the inorder traversal is ABCDEFG.
She thought that such a pair of strings would give enough information to reconstruct the tree later (but she never tried it).

Now, years later, looking again at the strings, she realized that reconstructing the trees was indeed possible, but only because she never had used the same letter twice in the same tree.
However, doing the reconstruction by hand, soon turned out to be tedious.
So now she asks you to write a program that does the job for her!

Input

The input will contain one or more test cases.
Each test case consists of one line containing two strings preord and inord, representing the preorder traversal and inorder traversal of a binary tree. Both strings consist of unique capital letters. (Thus they are not longer than 26 characters.)
Input is terminated by end of file.

Output

For each test case, recover Valentine's binary tree and print one line containing the tree's postorder traversal (left subtree, right subtree, root).

Sample Input

DBACEGF ABCDEFG
BCAD CBAD

Sample Output

ACBFGED
CDAB

#include<stdio.h>
#include<string.h>
#define M 30
char stack[M];
int top;

void Create(char *pre,char *in)
{
	char ps1[M],ps2[M],*qs1,*qs2;
	int index;
	
	if(strlen(pre)){
		stack[top++]=pre[0];
		
		index=strchr(in,pre[0])-in;
		qs1=in;qs2=in+index+1;
		in[index]=0;

		strncpy(ps1,pre+1,index);
		ps1[index]=0;

		strcpy(ps2,pre+index+1);
		Create(ps2,qs2);
		Create(ps1,qs1);
	}
	return ;
}

int main()
{
	char pre[M],in[M];
	
	while(scanf("%s%s",pre,in)!=-1){
		top=0;
		Create(pre,in);
		while(top>0)
			printf("%c",stack[--top]);
		puts("");
	}
	return 0;
}
 

2、http://acm.hdu.edu.cn/showproblem.php?pid=1710

Binary Tree Traversals
Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 591    Accepted Submission(s): 242



 
 

  
  Problem Description
 
 
 
 

  
  A binary tree is a finite set of vertices that is either empty or consists of a root r and two disjoint binary trees called the left and right subtrees. There are three most important ways in which the vertices of a binary tree can be systematically traversed or ordered. They are preorder, inorder and postorder. Let T be a binary tree with root r and subtrees T1,T2.
  
  

  
  
In a preorder traversal of the vertices of T, we visit the root r followed by visiting the vertices of T1 in preorder, then the vertices of T2 in preorder.
  
  

  
  
In an inorder traversal of the vertices of T, we visit the vertices of T1 in inorder, then the root r, followed by the vertices of T2 in inorder.
  
  

  
  
In a postorder traversal of the vertices of T, we visit the vertices of T1 in postorder, then the vertices of T2 in postorder and finally we visit r.
  
  

  
  
Now you are given the preorder sequence and inorder sequence of a certain binary tree. Try to find out its postorder sequence.
  
  

 
 
 
 

  
   
 
 

 
 

  
  Input
 
 
 
 

  
  The input contains several test cases. The first line of each test case contains a single integer n (1<=n<=1000), the number of vertices of the binary tree. Followed by two lines, respectively indicating the preorder sequence and inorder sequence. You can assume they are always correspond to a exclusive binary tree.
  
  

 
 
 
 

  
   
 
 

 
 

  
  Output
 
 
 
 

  
  For each test case print a single line specifying the corresponding postorder sequence.
  
  

 
 
 
 

  
   
 
 

 
 

  
  Sample Input
 
 
 
 

  
  
   
   

    
    9
1 2 4 7 3 5 8 9 6
4 7 2 1 8 5 9 3 6
   
   

 
 

 
 

  
   
 
 



 
 

  
  Sample Output
 
 

 
 


  
  
   
   

    
    7 4 2 8 9 5 6 3 1
   
   

 
 

 
 

  
   
 
 



 
 

  
  Source
 
 

 
 

  
  HDU 2007-Spring Programming Contest 
 
 

 
 

  
   
 
 



 
 

  
  Recommend
 
 

 
 

  
  lcy
 
 

 
 

  
  #include<stdio.h>
#define M 1001
int stack[M];
int top;

void Create(int *pre,int plen,int *in,int ilen)
{
	int index;
	if(plen){
		stack[top++]=pre[0];
		for(index=0;in[index]!=pre[0];index++);
		Create(pre+index+1,plen-index-1,in+index+1,ilen-index-1);
		Create(pre+1,index,in,index);
	}
}

int main()
{
	int n,i;
	int pre[M],in[M];
	while(scanf("%d",&n)!=-1){
		for(i=0;i<n;i++)
			scanf("%d",pre+i);
		for(i=0;i<n;i++)
			scanf("%d",in+i);
		Create(pre,n,in,n);
		while(top)
			printf(top>1?"%d ":"%d/n",stack[--top]);
	}
	return 0;
}