前序+ 中序 中序+后序 生成二叉树

**package com.zzw.leetcode;

import java.util.ArrayList;
import java.util.List;

/**
 * @PACKAGE_NAME: com.zzw.leetcode
 * @NAME: Ergodic
 * @USER: zhaozhenwei
 * @DATE: 2021/7/22
 * @TIME: 6:15 下午
 * @Description:
 **/
public class Ergodic {
    static TreeNode root;

    static {
        TreeNode treeNode1 = new TreeNode(1);
        TreeNode treeNode2 = new TreeNode(2);
        TreeNode treeNode3 = new TreeNode(3);
        TreeNode treeNode4 = new TreeNode(4);
        TreeNode treeNode5 = new TreeNode(5);
        TreeNode treeNode6 = new TreeNode(6);
        TreeNode treeNode7 = new TreeNode(7);
        TreeNode treeNode8 = new TreeNode(8);
        TreeNode treeNode9 = new TreeNode(9);
        TreeNode treeNode10 = new TreeNode(10);
        TreeNode treeNode11 = new TreeNode(11);
        treeNode1.left = treeNode2;
        treeNode1.right = treeNode3;
        treeNode2.left = treeNode4;
        treeNode4.right = treeNode5;
        treeNode5.left = treeNode6;
        treeNode5.right = treeNode7;
        treeNode3.left = treeNode8;
        treeNode3.right = treeNode9;
        treeNode9.left = treeNode10;
        treeNode10.right = treeNode11;

        root = treeNode1;
    }

    static TreeNode createTreeByPreAndMid(int[] preorder, int[] inorder) {
        if (preorder == null || inorder == null || preorder.length != inorder.length) {
            return null;
        }
        return createTreeByPreAndMid(preorder, inorder, 0, preorder.length - 1, 0, inorder.length - 1);
    }

    static TreeNode createTreeByPreAndMid(int[] pre, int[] mid, int start0, int end0, int start1, int end1) {
        if (start0 > end0 || start1 > end1) {
            return null;
        }
        // 获取当前子树的根节点
        int rootNum = pre[start0];
        TreeNode root = new TreeNode(rootNum);
        // 通过根节点将前序遍历、中序遍历序列切成左右两个部分
        // 1.找到根节点在中序遍历中的位置（左子树的长度）
        int len = 0;
        for (int i = start1; i < end1; i++) {
            if (rootNum == mid[i]) {
                break;
            }
            len++;
        }

        // 2.将前序、中序遍历切分成两个部分
        // 前序 左子树
        int start00 = start0 + 1;
        int end00 = start0 + len;
        // 前序 右子树
        int start01 = start0 + len + 1;
        int end01 = end0;

        // 中序 左子树
        int start10 = start1;
        int end10 = start1 + len - 1;

        // 中序右子树
        int start11 = start1 + len + 1;
        int end11 = end1;

        // 使用左右两个部分递归调用本方法获取当前子树的左右节点
        root.left = createTreeByPreAndMid(pre, mid, start00, end00, start10, end10);
        root.right = createTreeByPreAndMid(pre, mid, start01, end01, start11, end11);
        return root;
    }


    static TreeNode createTreeByMidAndPost(int[] mid, int[] post) {
        if (mid == null || post == null || mid.length != post.length) {
            return null;
        }
        return createTreeByMidAndPost(mid, post, 0, mid.length - 1, 0, post.length - 1);
    }

    static TreeNode createTreeByMidAndPost(int[] mid, int[] post, int start0, int end0, int start1, int end1) {
        // 判断当前是否存在数据
        if (start0 > end0 || start1 > end1) {
            return null;
        }
        // 找到后续遍历中的最后一个元素，该元素是当前子树的根节点
        int root = post[end1];
        TreeNode treeNode = new TreeNode(root);

        // 找到后续遍历最后一个元素在中序遍历中的位置，以找到的元素距离中序遍历结果的第一个元素的具体为主
        int len = 0;
        for (int i = start0; i < end0; i++) {
            if (root == mid[i]) {
                break;
            }
            len++;
        }

        // 通过在中序遍历中找到的位置将中序遍历分成两个部分，不包含找到元素
        // 中序遍历 左子树部分
        int start00 = start0;
        int end00 = start00 + len - 1;
        // 中序遍历 右子树部分
        int start01 = start0 + len + 1;
        int end01 = end0;

        // 通过中序遍历中左右两个字序列的长度将后续遍历也分成两个部分，不包含最后一个元素。
        // 后续遍历左子树
        int start10 = start1;
        int end10 = start1 + len - 1;

        int start11 = start1 + len;
        int end11 = end1 - 1;

        // 使用中序遍历后续遍历集合被分成左右两部分的集合各调用一次本方法
        treeNode.left = createTreeByMidAndPost(mid, post, start00, end00, start10, end10);
        treeNode.right = createTreeByMidAndPost(mid, post, start01, end01, start11, end11);

        return treeNode;
    }

    public static void main(String[] args) {
        List<Integer> result = new ArrayList<>();
        int[] pre = {1, 2, 4, 5, 6, 7, 3, 8, 9, 10, 11};
        int[] mid = {4, 6, 5, 7, 2, 1, 8, 3, 10, 11, 9};
        int[] post = {6, 7, 5, 4, 2, 8, 11, 10, 9, 3, 1};

        TreeNode treeNode = createTreeByPreAndMid(pre, mid);
        postOrderTraversal(treeNode, result);
        System.out.println(result);
    }

    static void preorderTraversal(TreeNode treeNode, List<Integer> resut) {
        if (null == treeNode) {
            return;
        }
        resut.add(treeNode.val);
        preorderTraversal(treeNode.left, resut);
        preorderTraversal(treeNode.right, resut);
    }

    static void middleOrderTraversal(TreeNode treeNode, List<Integer> resut) {
        if (null == treeNode) {
            return;
        }
        middleOrderTraversal(treeNode.left, resut);
        resut.add(treeNode.val);
        middleOrderTraversal(treeNode.right, resut);
    }

    static void postOrderTraversal(TreeNode treeNode, List<Integer> resut) {
        if (null == treeNode) {
            return;
        }
        postOrderTraversal(treeNode.left, resut);
        postOrderTraversal(treeNode.right, resut);
        resut.add(treeNode.val);
    }

}
**