构造二叉树

106 从中序和后序遍历序列构造二叉树

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

思路：后续遍历最后一个值为根节点，利用hashMap存储中序遍历，方便后续找到中序遍历的下标。利用四个指针，分别指向中序遍历和后序遍历的下标位置。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    HashMap<Integer,Integer> memo = new HashMap();
    int[] post;
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        for(int i=0;i<inorder.length;i++){
            memo.put(inorder[i],i);
        }
        post = postorder;
        TreeNode root = buildTree(0,inorder.length-1,0,post.length-1);
        return root;
    }
    public TreeNode buildTree(int inLeft,int inRight,int poLeft,int poRight){
        if(inLeft>inRight||poLeft>poRight) return null;
        int root = post[poRight];
        int inIndex = memo.get(root);
        TreeNode node = new TreeNode(root);
        node.left = buildTree(inLeft,inIndex-1,poLeft,poLeft+inIndex-1-inLeft);
        node.right = buildTree(inIndex+1,inRight,poLeft+inIndex-inLeft,poRight-1);
        return node;
    }
}

105 从前序与中序遍历序列构造二叉树

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

思路：与上题差不多，前序遍历序列开头为中心元素。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    HashMap<Integer,Integer> memo = new HashMap();
    int[] pre;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        for(int i=0;i<inorder.length;i++){
            memo.put(inorder[i],i);
        }
        pre = preorder;
        TreeNode root = buildTree(0,inorder.length-1,0,preorder.length-1);
        return root;
    }
    public TreeNode buildTree(int inLeft,int inRight,int preLeft,int preRight){
        if(inLeft>inRight||preLeft>preRight) return null;
        int root = pre[preLeft];
        int inIndex = memo.get(root);
        TreeNode node = new TreeNode(root);
        node.left = buildTree(inLeft,inIndex-1,preLeft+1,preLeft+inIndex-inLeft);
        node.right = buildTree(inIndex+1,inRight,preLeft+inIndex-inLeft+1,preRight);
        return node;
    }
}

19 最大二叉树

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值 左边 的 子数组前缀上 构建左子树。
递归地在最大值 右边 的 子数组后缀上 构建右子树。
返回 nums 构建的 最大二叉树 。

思路：定义一个函数，可以寻找自定义始末位置的数组中的最大值。递归函数首先调用该函数，寻找到最大值，再从hash表中拿出下标记，同时递归求左右子树，更新范围即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int[] numsTmp;
    HashMap<Integer,Integer> memo = new HashMap();
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        for(int i=0;i<nums.length;i++){
            memo.put(nums[i],i);
        }
        numsTmp = nums;
        TreeNode root = constructMaximumBinaryTree(0,nums.length-1);
        return root;
    }
    public TreeNode constructMaximumBinaryTree(int start,int end){
        if(start>end) return null;
        int root = getMax(numsTmp,start,end);
        int inIndex = memo.get(root);
        TreeNode node = new TreeNode(root);
        node.left = constructMaximumBinaryTree(start,inIndex-1);
        node.right = constructMaximumBinaryTree(inIndex+1,end);
        return node;
    }
    public int getMax(int[] nums,int start,int end){
        int max = nums[start];
        for(int i=start;i<=end;i++){
            if(nums[i]>=max){
                max = nums[i];
            }
        }
        return max;
    }
}