pat-1020* Tree Traversals

给后序和中序遍历
求层序遍历

Sample Input:7
2 3 1 5 7 6 4
1 2 3 4 5 6 7

Sample Output:4 1 6 3 5 7 2

注意如果是按char型处理，还要考虑多字符情况 如12
在输入上要加以处理，用int比较简单

#include "stdio.h"
#include "stdlib.h"


typedef struct bt_node    // 定义二叉树结点。
{
   char data ;
   struct bt_node * left ;
   struct bt_node * right ;
} bt_node ;

//搜索根在中序数组中的下标，若两个序列存在逻辑错误结束程序。
int search(char in[] , int inl , int inh , char ch)
{
   int i ;
   for(i=inl;i<=inh;i++)
   {
       if(in[i]==ch) return i ;
   } 
   printf("两个序列相互矛盾，无法构造二叉树!\n") ;
   exit(1) ;
}

//中根序列、后跟序列构造二叉树。
bt_node * create_bt1(char in[],int inl,int inh,char post[],int postl,int posth)
{
   int mid ;
   bt_node * r ;
   if(inl>inh||postl>posth) return NULL; //递归结束条件。
   mid    = search(in , inl , inh , post[posth]) ; //搜索根在中序数组中的下标。
   //printf("%d\n" , mid) ;可以通过这个语句查看有没有搜索正确。
   r = (bt_node *)malloc(sizeof(bt_node)) ;
   r->data = post[posth] ; //构造根结点。
   r->left = create_bt1(in,inl,mid-1, post,postl,postl+mid-inl-1) ; //构造左子树。
   r->right = create_bt1(in,mid+1,inh, post,postl+mid-inl,posth-1) ; //构造右子树。
   return r ; //返回根指针。
}

bt_node * create_bt2(char in[],int inl,int inh,char pre[],int prel,int preh)
{
   int mid ;
   bt_node * r ;
   if(inl>inh||prel>preh) return(NULL) ;
   mid = search(in , inl , inh , pre[prel]) ;
   //printf("%d\n" , mid) ;可以通过这个语句查看有没有搜索正确。
   r = (bt_node *)malloc(sizeof(bt_node)) ;
   r->data = pre[prel] ;
   r->left = create_bt2(in,inl,mid-1, pre,prel+1,prel+mid-inl) ;
   r->right = create_bt2(in,mid+1,preh, pre,prel+mid-inl+1,preh) ;
   return(r) ;
}

void pre_order(bt_node * r)
{
   if(r==NULL) return ;
   putchar(r->data) ;
   pre_order(r->left) ;
   pre_order(r->right) ;
}

void in_order(bt_node * r)
{
   if(r==NULL) return ;
   in_order(r->left) ;
   putchar(r->data) ;
   in_order(r->right) ;
}

void post_order(bt_node * r)
{
   if(r==NULL) return ;
   post_order(r->left) ;
   post_order(r->right) ;
   putchar(r->data) ;
}

//定义链队列结点。
typedef struct queue_node
{
   struct bt_node * bt_node_pointer ;
   struct queue_node * next ;
} queue_node ;

//二叉树的层次遍历。
void wfs_order(bt_node * r)
{
   queue_node * front , * rear , * mid ;
   front = (queue_node *)malloc(sizeof(queue_node)) ;
   rear = front ;
   mid = front ; //定义一个队列，并给予初始化。

   rear->bt_node_pointer = r ;
   rear = (queue_node *)malloc(sizeof(queue_node)) ;
   mid->next = rear ;
   mid = rear ; //r进队。

   while(front!=rear) //front!=rear指队列非空。
   {
       r = front->bt_node_pointer ;
	   printf("%d",r->data) ; //r出队，并打印r->data。
       front = front->next ;


       if(r->left != NULL) //r->left进队。
       {
           rear->bt_node_pointer = r->left ;
           rear = (queue_node *)malloc(sizeof(queue_node)) ;
           mid->next = rear ;
           mid = rear ;
       }

       if(r->right != NULL) //r->right进队。
       {
           rear->bt_node_pointer = r->right ;
           rear = (queue_node *)malloc(sizeof(queue_node)) ;
           mid->next = rear ;
           mid = rear ;
       }    

	   if(front != rear)
		   putchar(' ');
   }
}


int main()
{
	int N;
	int num;
	scanf("%d",&N);
	getchar();
	char* post = new char[N];
	char* in = new char[N];

	for(int i=0;i<N;i++)
	{
		scanf("%d",&num);
		post[i] = num;
	}

	for(int i=0;i<N;i++)
	{
		scanf("%d",&num);
		in[i] = num;
	}

	 bt_node * root = create_bt1(in,0,N-1, post,0,N-1);
	 wfs_order(root) ;
     putchar('\n') ;

	 return 0;
}