中序前序后序层序转换总结

模板

链表版（直接建树）

1.前序中序建树

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 1e4 + 10;
struct node{    
    node *lchild;
    node *rchild;
    int data;
};
int inter[maxn], pre[maxn], num, cur;
int Findroot(int n){ //在中序中找到n的位置 
    for(int i = 0; i < num; i++){   
        if(inter[i] == n) return i;
    }
    return -1;
}
void buildtree(node* &T, int left, int right){  
    if(right < left || cur >= num) return;
    int root = pre[cur];
    cur++;
    int index = Findroot(root);
    T = new node();
    T->data = root; 
    buildtree(T->lchild,left,index-1);
    buildtree(T->rchild,index+1, right);
}
int main(){
	int i;
	cin >> num;
	for(i = 0; i < num; i++ ) scanf("%d", &inter[i]);
	for(i = 0; i < num; i++ ) scanf("%d", &pre[i]);
	node* T; cur=0;
	buildtree(T,0,num-1);
}

2. 后序中序建树

void build(node* &T,int left,int right)
{
	if(right<left)return ;
	int root=post[cur];
	cur--;
	int Index=findIndex(root);
	T=new node();
	T->val=root;
	if(right==left){ //叶子结点 
		T->left=NULL;
		T->right=NULL;
	}
	else{
		build(T->right,Index+1,right);
		build(T->left,left,Index-1);
	}
}

数组版

1. 后序中序 -> 前序

void pre(int root, int start, int end) {
    if(start > end) return ;
    int i = start;
    while(i < end && in[i] != post[root]) i++;
    printf("%d ", post[root]);
    pre(root - 1 - end + i, start, i - 1);
    pre(root - 1, i + 1, end);
}

2. 前序中序-> 后序

void post(int root, int start, int end) {
    if(start > end) 
        return ;
    int i = start;
    while(i < end && in[i] != pre[root]) i++;
    post(root + 1, start, i - 1);
    post(root + 1 + i - start, i + 1, end);
    printf("%d ", pre[root]);
}

3. 前序后序-> 多少中序

void getintern(int prel,int prer, int endl, int endr ){    
	if( prel > prer || endl > endr) return;
	if(prel == prer) {								//遇到叶子节点剪枝， 否则很难判断其是否还有孩子例如测试点1中7的孩子传参 5 6 0 1
        ansintern.push_back(pre[prel]); 
        return;
    }
	int i = prer; // 在前序中寻找等于后序根前的节点
	while(i >=prel && pre[i] != post[endr - 1] ) i--;
	if(pre[prel + 1] == pre[i]) {// 若该根只有一侧有子树， 无法区分中左右和左右中
		flag = 0;
	}
	getintern(prel + 1, i - 1, endl, endr - (prer - i + 1 + 1));// 前序的左子树范围 根的下一个到 i的前一个， 后序左子树的范围 左侧不变右侧从原先往回找i + 2个(i 从enr - 1开始）
	ansintern.push_back(pre[prel]); 
   	getintern(i , prer, endr -  (prer - i  + 1),  endr - 1);		//前序右子树范围： 左侧i， 右侧不变， 后序的右子树： 左侧接后序左子树， 右侧为根的前一个
}

4. 中序后序建树

int cnt = 0;
int maketree(int root, int start, int ends, int index){
    if(start > ends) return -1;
    node temp = {post[root], -1, -1, index};
    int i = ends;
    while(i >= start && intern[i] != post[root]) i--;
    temp.left = maketree(root - (ends - i + 1), start, i - 1, index * 2 + 1);
    temp.right = maketree(root - 1, i + 1, ends, index * 2 + 2);
    a.push_back(temp);
    myhash[temp.data] = cnt;
    return cnt++;
}
	

注： index用于确定层次序列中的编号，myhash用于通过节点的内容找到树中的位置，建树完成后根在数组的最后面， cnt 位置

5. 搜索树 + 前序 -> 后序

void  getpost(int root, int tail){
    if(root > tail) return ;
    int i = root + 1, j = tail;
    if(mirror_flag == 0){
        while(i <= tail && pre[i] < pre[root]) i++;
        while(j > root && pre[j] >= pre[root]) j--;
    if(i  != j + 1) return;
    getpost(root + 1, i - 1);
    getpost(j + 1, tail);
    post.push_back(pre[root]);
}

题目

1143

1138

1135

1119

1102

1086

1064

1043

1020