树和二叉树

1. 树的存储与遍历

1.初始化二叉树

2.先序遍历二叉树

3.中序遍历二叉树

4.后序遍历二叉树

5.销毁二叉树

1. 二叉树的复原

1.由前序、中序序列确定复原二叉树

2.由中序、后序序列确定复原二叉树

//树和二叉树
#include<iostream>
#include<malloc.h>
#include<conio.h>
#include<windows.h>
using namespace std;
typedef struct Node
{
	char data;
	struct Node* LChild;
	struct Node* RChild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &bt)
{
	char ch;
	cin>>ch;
    if(ch=='.')
		bt=NULL;
    else 
	{
		bt=new BiTNode; //生成一个新结点
        bt->data=ch;
        CreateBiTree(bt->LChild); //生成左子树
        CreateBiTree(bt->RChild); //生成右子树
	}
}
void PreOrder(BiTree root) 
/*先序遍历二叉树, root为指向二叉树根结点的指针*/
{ 
	if (root!=NULL)
	{
		printf("%c  ",root ->data);  /*输出结点*/
		PreOrder(root->LChild);  /*先序遍历左子树*/
		PreOrder(root->RChild);  /*先序遍历右子树*/
	}
}
void InOrder(BiTree root) 
/*中序遍历二叉树, root为指向二叉树根结点的指针*/
{
	if (root!=NULL)
	{
		InOrder(root->LChild);  /*中序遍历左子树*/
		printf("%c  ",root ->data);  /*输出结点*/
		InOrder(root->RChild);  /*中序遍历右子树*/
	}
}
void PostOrder(BiTree root) 
/*后序遍历二叉树, root为指向二叉树根结点的指针*/
{
	if (root!=NULL)
	{
		PostOrder(root->LChild);  /*后序遍历左子树*/
		PostOrder(root->RChild);  /*后序遍历右子树*/
		printf("%c  ",root ->data);  /*输出结点*/
	}
}
void DestroyNode(BiTNode* node)
{
     delete node;
}
void TreeDestroy(BiTNode** root)
{
    if(root==NULL)
    {
        //非法
        return ;
    }
    if(*root==NULL)
    {
        //空树
        return ;
    }
    TreeDestroy(&((*root)->LChild));
    TreeDestroy(&((*root)->RChild));
    DestroyNode(*root);
    *root=NULL;
    return ;
 }  
int main()
{
	int a;
	BiTree root;
	do{
		printf("\t  1、初始化二叉树 \n");
	    printf("\t  2、先序遍历二叉树 \n");
	    printf("\t  3、中序遍历二叉树 \n");
	    printf("\t  4、后序遍历二叉树 \n");
	    printf("\t  5、销毁二叉树  \n");
	    printf("\t  0、退出二叉树  \n");
		scanf("%d",&a);
		system("CLS");
		if(a==1)
		{
			CreateBiTree(root);
		}
		else if(a==2)
		{
			PreOrder(root);
			if(root!=NULL)
			{
				cout<<endl;
			}
			else
			{
				cout<<"空树！"<<endl; 
			}
		}
		else if(a==3)
		{
			InOrder(root);
			if(root!=NULL)
			{
				cout<<endl;
			}
			else
			{
				cout<<"空树！"<<endl; 
			}
	    }
	    else if(a==4)
	    {
			PostOrder(root);
			if(root!=NULL)
			{
				cout<<endl;
			}
			else
			{
				cout<<"空树！"<<endl; 
			}
		}
		else if(a==5)
		{
			TreeDestroy(&root);
		}
	}
	while(a!=0);
	cout<<"班级：计21-2班   姓名：沈润晨   学号：214010219"<<endl;
	return 0;
}

#include<stdio.h>
#include<stdlib.h>
typedef struct BiTree
{
    int data;
    struct BiTree* lchild;
    struct BiTree* rchild;
}bitnode,*bitree;
bitree RestoreTree(char* pre,char* in,int q1,int q2,int z1,int z2);
char in[50],pre[50];
int main()
{
    int n;
	printf("请输入二叉树的结点数量：\n");
	scanf("%d",&n);
	getchar();
	printf("请输入先序遍历实例：\n");
	for(int i = 0;i < n;i++)
		scanf("%c",&pre[i]);
	getchar();
	printf("请输入中序遍历实例：\n");
	for(int i = 0;i < n;i++)
		scanf("%c",&in[i]);
	printf("后序遍历输出：\n");
    RestoreTree(pre,in,0,n-1,0,n-1);
    return 0;
}
bitree RestoreTree(char* pre,char* in,int q1,int q2,int z1,int z2)
{
    for(int i = z1;i<=z2;i++)
    {
        if(in[i]==pre[q1])
        //根据先序找到中序的根结点，把树分成左右两个子树进行递归 
        {
            if(i!=z1)
            //存在左子树,访问左子树
                RestoreTree(pre,in,q1+1,q1+i-z1,z1,i-1);
            if(i!=z2)
            //存在右子树,访问右子树
                RestoreTree(pre,in,q1+i-z1+1,q2,i+1,z2);
            break;//找到以后跳出遍历
        }
    }
    printf("%c",pre[q1]);//输出先序的开始位置，就是后序的结束位置 
}

#include<stdio.h>
typedef struct Bitree{
	char data;
	struct Bitree* lchild;
	struct Bitree* rchild;
}*bitree,bitnode;
void Restoretree(int h1,int h2,int z1,int z2);
char in[50],post[50];
int main(void)
{
	int n;
	printf("请输入二叉树的结点数量：\n");
	scanf("%d",&n);
	getchar();
	printf("请输入后序遍历实例：\n");
	for(int i = 0;i < n;i++)
		scanf("%c",&post[i]);
	getchar();
	printf("请输入中序遍历实例：\n");
	for(int i = 0;i < n;i++)
		scanf("%c",&in[i]);
	printf("前序遍历输出：\n");
	Restoretree(0,n-1,0,n-1);
	printf("\n");
	return 0;
}

void Restoretree(int h1,int h2,int z1,int z2)
//参数分别为后序的开始位置和结束位置，中序的开始位置和结束位置 
{
	printf("%c ",post[h2]);//输出后序的结束位置，就是先序的开始位置 
	for(int i = z1;i <= z2;i++)
	{
		if(in[i]==post[h2])
		//根据后序找到中序的根结点，把树分成左右两个子树进行递归 
		{
			if(i!=z1)//存在左子树,访问左子树
				Restoretree(h1,h1+i-z1-1,z1,i-1);
			if(i!=z2)//存在右子树,访问右子树
				Restoretree(h2-z2+i,h2-1,i+1,z2);
			break;//找到以后跳出遍历
		}
	}
}