由树的先序和中序遍历生成树的层序遍历后序遍历

//此为多文件结构

//binarry.h

#pragma once

#include <iostream>
#include <tchar.h>
#include <stdio.h>

using namespace std;

 

//BiTree_Node.h

#pragma once

#include "binarry_tree.h"
//树的结点类型
typedef struct Binarry_Tree
{
 int data;//结点记录
 Binarry_Tree *left;//左子树
 Binarry_Tree *right;//右子树
}*Bi_Tree;

 

//Queue_Link.h

#pragma once

#include "BiTree_Node.h"

//队列结点
typedef struct Queue_Node
{
 Bi_Tree treenode;//树结点
 Queue_Node *next;//队列结点的后继
}*Q_Node;//队列结点类型

//队列类型
typedef struct Queue
{
 Q_Node head;//头指针
 Q_Node tail;//尾指针
}*_Queue;//队列类型

//创建队列
void Create_Queue(_Queue &queue)
{
 queue = new Queue;
 queue->head = NULL;
 queue->tail = NULL;
}

//创建队列结点
void Init_QNode(Q_Node &q_node)
{
 q_node = new Queue_Node;
 q_node->treenode = NULL;
 q_node->next = NULL;
}

//赋值结点
void Set_QNode(Q_Node &q_node,Bi_Tree &treenode)
{
 q_node->treenode = treenode;
}

//判断队是否为空
bool Queue_Empty(_Queue &queue)
{
 if(queue->head == NULL)
  return true;
 else
  return false;
}

//入队
void En_Queue(_Queue &queue,Q_Node &q_node)
{
 if(queue->head !=NULL)
 {
  queue->tail->next = q_node;
  queue->tail = queue->tail->next;
 }
 else
 {
  queue->head = q_node;
  queue->tail = q_node;
 }
}

//出队
void De_Queue(_Queue &queue,Q_Node &q_node)
{
 if(queue->head != queue->tail)
 {
  q_node = queue->head;
  queue->head = queue->head->next;
  q_node->next = NULL;
 }
 else
 {
  q_node = queue->head;
  queue->head = NULL;
  queue->tail = NULL;
 }
}

//队列销毁
void Destory_Queue(_Queue &queue)
{
 Q_Node node;
 while(!Queue_Empty(queue))
 {
  De_Queue(queue,node);
  delete node;
 }
 delete queue;
}

//BiTree.h

#pragma once

#include "BiTree_Node.h"
#include "Queue_Link.h"

//创建结点
void Init_BiTree(Bi_Tree &tree)
{
 tree = new Binarry_Tree;
 tree->data = 0;
 tree->left = NULL;
 tree->right = NULL;
}
//创建二叉树
void Create_tree(Bi_Tree &tree,int *pretraverse,int *intraverse,
   int length)
{ 
 if(pretraverse != NULL && intraverse != NULL && length>0)
 {
  int inrear = 0;
  Init_BiTree(tree);
  tree->data = pretraverse[0];
  for(;;)
  {
   if(pretraverse[0] == intraverse[inrear] || inrear ==length)
   {
    break;
   }
   inrear++;
  }
  
  int leftlength = inrear;
  if(leftlength > 0)
  {
   Create_tree(tree->left,pretraverse+1,intraverse,leftlength);
   Create_tree(tree->right,pretraverse+leftlength+1,
        intraverse+leftlength+1,length-leftlength-1);
  }
 }
}
//访问结点
void visit(int data)
{
 cout<<data<<"  ";
}
//后序遍历
void PostOrderTraverse(Bi_Tree &tree,void (*visit)(int))
{
 if(tree != NULL)
 {
  if(tree->left != NULL)
   PostOrderTraverse(tree->left,visit);
  if(tree->right != NULL)
   PostOrderTraverse(tree->right,visit);
  visit(tree->data);
 }
}

//层序遍历
void LavalOrderTraverse(Bi_Tree tree,void (*visit)(int))
{
 if(tree !=NULL)
 {
  _Queue queue;//队列
  Q_Node q_node;//队列结点
  Bi_Tree newtree = NULL;

  Create_Queue(queue);
  Init_QNode(q_node);
  Set_QNode(q_node,tree);
  En_Queue(queue,q_node);

  while(!Queue_Empty(queue))
  {
   De_Queue(queue,q_node);
   newtree = q_node->treenode;
   visit(newtree->data);
   if(newtree->left != NULL)
   {
    Init_QNode(q_node);
    Set_QNode(q_node,newtree->left);
    En_Queue(queue,q_node);
   }
   if(newtree->right != NULL)
   {
    Init_QNode(q_node);
    Set_QNode(q_node,newtree->right);
    En_Queue(queue,q_node);
   }
  }
  Destory_Queue(queue);
 }
}

//Binarry_Tree.cpp

//由树的先序和中序遍历生成树的层序遍历后序遍历
//给定一棵树的先序和中序的遍历结果，构建二叉树，并输出这个棵树的层序遍历和后序遍历结果

#include "BiTree.h"

int _tmain(int argc,_TCHAR* argv[])
{
 int m = 0;//树结点总数

 Bi_Tree tree;
 /*int pretraverse[15]= {1,2,4,8,9,5,10,11,3,6,12,13,7,14,15};//先序遍历结果
 int intraverse[15]= {8,4,9,2,10,5,11,1,12,6,13,3,14,7,15};//中序遍历结果*/

 int *pretraverse,*intraverse;//先序遍历和中序遍历结果
 int *visitcout;//访问记录跟踪标记
 pretraverse = NULL;
 intraverse = NULL;
 visitcout = NULL;
 cout<<"请输入树结点总数："<<endl;
 cin>>m;
 if(m>0)
 {
  pretraverse = new int[m];
  intraverse = new int[m];
 }
 cout<<"请输入先序遍历结果"<<endl;
 for(int i=0;i<m;i++)
 {
  cin>>pretraverse[i];
 }
 cout<<"请输入中序遍历结果"<<endl;
 for(int i=0;i<m;i++)
 {
  cin>>intraverse[i];
 }

 Create_tree(tree,pretraverse,intraverse,15);
 cout<<"后序遍历："<<endl;
 PostOrderTraverse(tree,visit);
 cout<<endl<<"层序遍历："<<endl;
 LavalOrderTraverse(tree,visit);
 cout<<endl;
 return 0;
}