老会忘的二叉树遍历建树输出

前中输出后

#include<iostream>  
using namespace std;  
int pre[] = {1, 2, 3, 4, 5, 6};  
int mid[] = {3, 2, 4, 1, 6, 5};  
void post(int root, int start, int end) 
{  
    if(start > end)   
        return ;  
    int i = start;  
    while(i < end && mid[i] != pre[root]) i++;  //定位根在中序的位置
    post(root + 1, start, i - 1);  //递归处理左子树
    post(root + 1 + i - start, i + 1, end);  //递归处理右子树
    //cout<<pre[root];  //访问当前树的根
    cout<<mid[i];
}  

int main() 
{  
    post(0, 0, 5);  
    return 0;  
} 

后中输出前

#include<iostream>  
using namespace std;  
int post[] = {3, 4, 2, 6, 5, 1};  
int mid[] = {3, 2, 4, 1, 6, 5};  
void pre(int root, int start, int end) 
{  
    if(start > end)   
        return ;  
    int i = start;  
    while(i < end && mid[i] != post[root]) i++;  //定位根在中序的位置
    cout<<mid[i];  //访问当前处理的树的根
    pre(root-1-(end-i), start, i - 1);  //递归处理左子树
    pre(root-1, i + 1, end);  //递归处理右子树  
}  

int main()
 {  
    pre(5, 0, 5);  
    return 0;  
}

先中序建树

TreeNode reConstructBinaryTree(int[] pre, int preStart, int preEnd, int[] in, int inStart, int inEnd) {
    if (preStart > preEnd || inStart > inEnd) { //到达边界条件时返回null
        return null;
    }
    TreeNode treeNode = new TreeNode(pre[preStart]);   //新建一个TreeNode

    for (int i = inStart; i <= inEnd; i++) {
        if (in[i] == pre[preStart]) {    //在中序中找到根节点的位置，【依次】将先序序列和中序序列分成左右字树，分别构建左右子树。
            // 重构左子树，注意边界条件
            treeNode.left = reConstructBinaryTree(pre, preStart + 1, preStart + i - inStart, in, inStart, i - 1);
            // 重构右子树，注意边界条件
            treeNode.right = reConstructBinaryTree(pre, preStart + i - inStart + 1, preEnd, in, i + 1, inEnd);
        }
    }
    return treeNode;
}

 

后中序建树

TreeNode reConstructBinaryTree2(int[] in, int inStart, int inEnd, int[] last, int lastStart, int lastEnd) {
    if (inStart > inEnd || lastStart > lastEnd)
        return null;
    TreeNode treeNode = new TreeNode(last[lastEnd]);
    for (int i = inStart; i <= inEnd; i++) {
        if (in[i] == last[lastEnd]) {
            treeNode.left = reConstructBinaryTree2(in, inStart, i - 1, last, lastStart, lastStart + i - inStart - 1);
            treeNode.right = reConstructBinaryTree2(in, i + 1, inEnd, last, lastStart + i - inStart, lastEnd - 1);
        }
    }
    return treeNode;
}

 

二叉搜索树前序输出后序

vector<int> v;
void getpost(int root, int last) {
    int i = root + 1, j = last;
    while (a[i] < a[root] && i <= last)i++;//找当前根节点左子节点边界
    while (a[j] >= a[root] && j > root)j--;//找当前根节点右子节点边界
    if (i - j != 1)return;
    getpost(root + 1, j);//遍历左子节点
    getpost(i, last);//遍历右子节点
    v.push_back(a[root]);//pb根节点(左右根)
}

*给出二叉搜索树的一个遍历，只要从小到大排序就是其中序遍历，根据中序遍历从0下标开始在进行左根右遍历得到层序遍历 

 

二叉树后中序输出层序

int post[1005], in[1005];
map<int, int> ma, le;
void level(int root, int l, int r, int index) {
    if (l > r)return;
    int p = ma[post[root]];//当前后序所在根节点前序位置
    le[index] = post[root];//index为节点下标
    level(root - r + p - 1, l, p - 1, 2 * index);//root - (r - p) - 1是当前后序根节点位置减去(其右子树节点个数)再减一位
    level(root - 1, p + 1, r, 2 * index + 1);
}

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> post[i];
    }
    for (int i = 1; i <= n; i++) {
        cin >> in[i];
        ma[in[i]] = i;
    }
    level(n, 1, n, 1);
}