二叉树创建——中序后序遍历 / 只中序遍历+二分法

中序+后序遍历 创建二叉树

/**
 * 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 {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        /**
        切分+递归
        再写一个递归的处理
         */
        if (inorder.length == 1) {
                TreeNode root = new TreeNode();
                root.val = inorder[0];
                return root;
        }
        //创建hashmap 建立 inorderinorder中数字和下标
        //对于postorder而言,不需要hashmap来保存下标,因为根节点就是当前的postorder的最后一个元素
        HashMap<Integer,Integer> inorderHash = new HashMap<>();
        int local = 0;
        for (int i : inorder) {
            inorderHash.put(i,local);
            local++;
        }
 
        return DFS(inorder,postorder,0,inorder.length,0,postorder.length,inorderHash);
        // DFS(inorder,postorder,root);

    }
    public TreeNode DFS(int[] inorder, int[] postorder, int inorderBegin, int inorderEnd, int postorderBegin, int postorderEnd, HashMap<Integer,Integer> inorderHash) {
        /**
        所有的数组下标采取左闭右开原则
        保存inorder当前的起始和postorder当前的起始
        然后通过切分确定当前序列的根节点
        最后在调用递归
        使用递归来进行切割中序遍历和后续遍历的数组

         */
        if (inorderEnd - inorderBegin <= 0 || postorderEnd - postorderBegin <= 0) {
            return null;
        }
        // TreeNode node = new TreeNode();
        //获取中序的节点序号

        int mid = inorderHash.get(postorder[postorderEnd-1]);
        TreeNode root = new TreeNode();
        root.val = inorder[mid];

        root.left = DFS(inorder,postorder,inorderBegin,mid,postorderBegin,postorderBegin+mid-inorderBegin,inorderHash);
        root.right = DFS(inorder,postorder,mid+1,inorderEnd,postorderBegin+mid-inorderBegin,postorderEnd-1,inorderHash);

        //对于递归的返回总是存在一些问题
        /**
        在本题中,root是不断深入的,但是到最后,所有的创建完,才开始弹栈,最后把栈底的根结点弹出
         */
        return root;
    }
}

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * 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 {
    public TreeNode sortedArrayToBST(int[] nums) {
        /**
        本题中不需要考虑后序遍历,可以直接使用二分法对中序遍历的数组进行划分
        首先思路就是中值插入
        但是在二叉树中,顺序,可以首选中序遍历
        二分法+中序遍历创建二叉树
        */
        
        if (nums.length == 1) {
            TreeNode root = new TreeNode();
            root.val = nums[0];
            return root;
        }
        return DFS(nums,0,nums.length);

    }
    public TreeNode DFS(int[] nums, int inorderBegin, int inorderEnd) {
        if (inorderEnd - inorderBegin <= 0) {
            return null;
        }
        int mid = (inorderBegin + inorderEnd) / 2;
        TreeNode root = new TreeNode();
        root.val = nums[mid];
        root.left = DFS(nums,inorderBegin,mid);
        root.right = DFS(nums,mid+1,inorderEnd);
        return root;
    }
}