二叉树的各种题型详解

根据先序和中序求后序遍历

后续遍历就是先遍历左子树，然后是右子树，最后是根

由先序和中序，可以知道根和左右子树的位置，对其按照后续遍历的规则遍历即可

每次用k++，就可以获取先序的根节点，对于先序来说，其实一直都是根节点

获取rt 后，对中序切割，便可以得到左子树和右子树，对左右子树继续遍历

当 rt=f 时，说明没有左子树，当 rt =r 时，说明没有右子树，输出此节点即可

rt<f  和 rt>r 是什么情况？

只是为了保险。。。。

 

#include <cstdio>
char in[30], pre[30];
int mp[30], n;
void post(int f, int r) {
	static int k = -1;
	char x = pre[++k];//获取根节点 
	int rt = mp[x-'a'];//获取在中序的位置 
	if (rt<f || rt>r) return;
	//下面的为后序遍历 
	if (rt > f) post(f, rt-1);//遍历左子树 
	if (rt < r) post(rt+1, r);//遍历右子树 
	putchar(x); //输出根节点 
}
int main() {
	scanf("%s%s", pre, in);
	for (n = 0; in[n]; ++n)
		mp[in[n]-'a'] = n;
	post(0, n-1);
	return 0;
}

扩展二叉树

扩展二叉树

#include <cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
typedef struct Tree{
	char c;
	Tree *left,*right;
}*Ltree;
void build(Ltree &rt){//这里必须是引用 
	char ch;
	cin>>ch;
	rt=new Tree();
	if(ch=='.') 
	  rt=NULL;//当回溯到根节点，输入也全部结束 
	else{
		rt->c=ch;
		build(rt->left);
		build(rt->right);
	}
}
void intravel(Ltree rt){
	if(rt==NULL)
	 return ;
	intravel(rt->left);
	cout<<rt->c;
	intravel(rt->right);
}
void post(Ltree rt){
	if(rt==NULL)
	  return ;
	post(rt->left);
	post(rt->right);
	cout<<rt->c;
}
int main(){
	Ltree rt;
	build(rt);
	intravel(rt);
	cout<<endl;
	post(rt);
}

二叉搜索树和前序遍历

 二叉搜索树的插入模板

#include<iostream>
using namespace std;
struct tree{
	int da;
	tree *le,*ri;
};
void insert(int a,tree* &root){//注意要用引用
	if(root==NULL){
		root=new tree();
		root->da=a;
		root->le=NULL;
		root->ri=NULL;
		return ;
	}
	if(a<root->da)
	 insert(a,root->le);
	else
	 insert(a,root->ri);
}
void pre(tree *root){
	if(root==NULL)
	 return ;
	cout<<root->da<<" "; 
	pre(root->le);
	pre(root->ri);
}
int main(){
	int n;
	cin>>n;
	tree *rt=NULL;
	int a;
	for(int i=1;i<=n;i++){
		cin>>a;
		insert(a,rt);
	}
	pre(rt);
}

1135 Is It A Red-Black Tree (30 分)

二叉搜索树的性质

 中序遍历的结果为从小到大排序

    1064 Complete Binary Search Tree (30 分)

​
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=10000;
int a[maxn];
int f[maxn];
int n,index;
void in(int rt){
	if(rt>n) return ;
	in(rt*2);
	f[rt]=a[++index]; 
	in(rt*2+1);
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	} 
	sort(a+1,a+1+n);
	in(1);
	for(int i=1;i<n;i++)
	  cout<<f[i]<<" ";
	cout<<f[n];
	return 0;
}

​

  （这里还有如何根据中序遍历满二叉树结果，输出层序遍历）

根据后序和先序建树

二叉树的重构只能由 先序/后序 +中序 构成
以先序+中序为例
假设一个二叉树的先序为: ABDECFG
                    中序为：DBEAFCG
由先序遍历的性质可知 A为根，在中序中找到A，
那么中序中A的左侧为左子树（DBE）右侧为右子树(FCG) ，
由此可以在先序中找到左子树的先序遍历为（BDE）,右子树的先序遍历为（CFG）。
对于左子树而言，在先序中找到根节点为B，在中序遍历中可知D为左子树，E为右子树。。。如此递归下去
递归的具体过程
`

1.首先在先序遍历中找到根节点
2.在中序遍历中找到根节点所在位置index（此时左子树的长度为index，右子树为len-index-1）
3.此时可以判断出左子树的先序遍历，中序遍历和右子树的先中遍历，
 递归循环即可

 
 代码给出的是后序+中序的重建
 

```
#include<bits/stdc++.h>
using namespace std;
typedef struct Tree
{
  int data;
  struct Tree *left,*right;
}Tree,*linktree;
int n;
int hou[120];
int zhong[120];
Tree* build(int *hou,int *zhong,int len)
{
    if(len<=0)
        return NULL;
    Tree* tmp=new Tree();
    tmp->data=hou[len-1];
    int index=0;
    for(int i=0;i<len;i++)
        if(zhong[i]==hou[len-1])
            {
                index=i;
                break;
            }
     tmp->left=build(hou,zhong,index); 
     //左子树的后序遍历与中序遍历的数组
     tmp->right=build(hou+index,zhong+index+1,len-index-1);
     //右子树的中序遍历与后序遍历的数组
     return tmp;
     //返回根节点
}
void preprintf(Tree* T)
{
    if(T)
    {
        printf("%d",T->data);
        preprintf(T->left);
        preprintf(T->right);
    }
}
void inprintf(Tree* T)
{
    if(T)
    {
        inprintf(T->left);
        printf("%d",T->data);
        inprintf(T->right);
    }
}
void postprintf(Tree* T)
{
    if(T)
    {
       postprintf(T->left);
       postprintf(T->right);
       printf("%d",T->data);
    }
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>zhong[i];
    for(int i=0;i<n;i++)
        cin>>hou[i];
    Tree* root=build(hou,zhong,n);
    preprintf(root);
    printf("\n");
    inprintf(root);
    printf("\n");
    postprintf(root);
    printf("\n");
    return 0;
}