树的重构（前序+中序 ， 后序+中序，完美二叉树）

用递归的方式写我感觉是最简单的了

前序+中序

#include<iostream>
#include<string>
#include<set>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int zhong[40], qian[40];
int root = 0;
typedef struct node* Node;
struct node {
	int data;
	Node left;
	Node right;
};
void Cen_Travel(Node T){};
//层序遍历的函数
void BuildTree(Node& T, int beg, int end) {
//指针指向的只是一片空间，你只能修改空间里面的内容，想要修改指针的指向，你需要传入指针的地址
	int pos = -1;//用来定位根节点再中序列的位置
	for (int i = beg; i <= end; i++)
	{
		if (zhong[i] == qian[root]) {
			pos = i;
			break;
		}
	}
	if (pos == -1) {
		T = NULL;
		return;
	}
	T = new struct node;
	T->data = qian[root];
	root++;
	//必须先左子树，然后右子树，不能换顺序，后面说
	BuildTree(T->left, beg, pos-1);
	BuildTree(T->right, pos+1, end);
	
}
int main()
{
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
		cin >> zhong[i];
	for (int i = 0; i < n; i++)
		cin >> qian[i];

	Node T;
	BuildTree(T, 0, n-1);
	Cen_Travel(T);
   return 0;
}

后序+中序

int root = n-1;
void BuildTree(Node &node,int beg, int end)
{
	int pos = -1;
	for (int i = beg; i <= end; i++) {
		if (zhong[i] == hou[root]) {
			pos = i;
			break;
		}
	}
	if (pos == -1) {
		node = NULL;
		return;
	}
	node = new struct node;
	node->data = hou[root];
	root--;
	//先右后左顺序不能换
	BuildTree(node->right, pos + 1, end);
	BuildTree(node->left, beg, pos-1);
}

解释

（先序就是先访问根节点，先序就是中间才访问根节点，后序就是最后访问根节点）

建议配合递归遍历的代码使用

1.为什么先序+中序是先左子树后右子树，而后序+中序是反着的：

先序：

我们先来看一下先序怎么遍历的。
首先访问根结点然后遍历左子树，最后遍历右子树。

所以我们输出的先序数列的第一个节点一定是树的根节点，然后我们先访问左子树，那么第二个节点就是当前子树（左子树）的根节点，然后继续访问左子树，所以第三个节点就是当前子树的根节点…
所以我们root++可以逐步找到每一个子树的根节点。这个子树在中序序列中对应的就是[beg,end],这个子树的左子树就是[beg,pos-1]，右子树就是[pos+1,end].
所以先对左子树进行重建。

后序：

后序同理，后序是最后访问根节点，所以最后一个节点就是整棵树的根节点。因为先访问左子树再访问右子树，所以后序序列靠近root的是属于右子树的。我们的rot从n-1开始，所以靠近root的节点是root对应树的右子树，所以先对右子树进行重建，右子树重建结束才是左子树。

总结

先序根在左，靠近root的对应的是左子树，先对左子树重建。
后序根在右，靠近root的对应的是右子树，先对右子树重建。

完美二叉树

还是递归建树，给的是后序序列，告诉我们这是一棵完美二叉树，要对这棵树进行层序遍历。

法一：这个方法借鉴了网上的一个方法。思路是这样的：后序遍历的走法，是先左后右最中，三种方法的遍历走向都是左右中，只不过什么时候访问中间节点。
后序

#include<iostream>
using namespace std;
int Nodes[100];
int n;
void BuildTree(int k) {
	if (2 * k <= n) BuildTree(2 * k);
	if (2 * k + 1 <= n) BuildTree(2 * k + 1);
	cin >> Nodes[k];
}
int main()
{
	
	cin >> n;
	BuildTree(1);
	for (int i = 1; i <= n; i++) {
		if (i != 1) cout << " ";
		cout << Nodes[i];
	}
	return 0;
}

方法二：这个方法我自己写的，但是还有一个测试点没过，等我找到问题再来改。
（有bug）

#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#include<string>
#include<stack>
#include<map>
#include<queue>
#include<set>
using namespace std;
typedef struct node* Node;
int datas[50];
vector<int>v;
struct node {
    int data;
    Node left;
    Node right;
};
void BuildTree(Node& T,int beg,int end) {
   
    if (end < beg) {
        T = NULL;
        return;
    }

    T = new struct node;
    T->data = datas[end];
    int cnt = (end -1 - beg + 1) / 2;
    BuildTree(T->right, end - cnt , end - 1);
    BuildTree(T->left, beg, end - cnt - 1);

}
void CenTravel(Node T) {
    queue<Node>q;
    q.push(T);
    while (!q.empty()) {
        Node temp = q.front();
        v.push_back(temp->data);
        q.pop();
        Node left = temp->left;
        if (left != NULL) q.push(left);
        Node right = temp->right;
        if (right != NULL) q.push(right);
    }

}
int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> datas[i];
    }
    Node T;
    BuildTree(T, 1, n);
    CenTravel(T);
    for (int i = 0; i < v.size(); i++) {
        if (i != 0) cout << " ";
        cout << v[i];
    }


    return 0;
}