力扣刷题记录 -- JAVA--51---106. 从中序与后序遍历序列构造二叉树

---

一、题目

二、代码

/**
 * 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 
{
    //中序遍历  左中右
    //后序遍历  左右中 
    //通过后序遍历 切割中序遍历
    //复杂的题目都可以使用全局变量
    Map<Integer, Integer> map;

    public TreeNode buildTree(int[] inorder, int[] postorder) 
    {
         map = new HashMap<>();
         for(int i = 0 ; i< inorder.length; i++)
         {
             map.put(inorder[i],i);
         }
         
         return findNode(inorder, 0, inorder.length,postorder, 0, postorder.length);
    }

    public TreeNode findNode(int[] inorder, int inBegin, int inEnd ,int[] postorder, int postBegin, int postEnd)
    {
        
         if(inBegin >= inEnd || postBegin >= postEnd)
         {
             return null;
         }
         int rootIndex = map.get(postorder[postEnd - 1]);
         TreeNode root = new TreeNode(inorder[rootIndex]);
         int lenOfLeft = rootIndex - inBegin;
         root.left =  findNode(inorder, inBegin, rootIndex,
                               postorder, postBegin, postBegin+lenOfLeft );
         root.right = findNode(inorder, rootIndex+1, inEnd,
                                postorder, postBegin + lenOfLeft,postEnd - 1);
         return root;
         

    }



}

三、运行结果

四、附录

二刷

/**
 * 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 == 0) return null;

        int i;
        int length = postorder.length;
        int val = postorder[length-1];

        int index = 0;
        length = inorder.length;

        for(i=0;i<length;i++)
        {
           if(inorder[i] == val)
           {
               index = i;
               break;
           }
        } 

        TreeNode root = new TreeNode(val);
        // int[] left =new int[index];
        // int[] right = new int[length_post-1-index]; 

        // for(i=0;i<index;i++)
        // {
        //     left[i] = inorder[i];
        //     System.out.println(" left  " +left[i]);
        // }
        // for(i=index+1;i<length_post;i++)
        // {
        //     right[i-index-1] = inorder[i]; 
        //     System.out.println(" right[i-index-1]  " +right[i-index-1]);
        // }
        //核心是为left 和 right区分好

        int[] left_in = new int[index];
        for(i=0;i<index;i++) left_in[i] = inorder[i];
        
        int[] right_in = new int[length-1-index];
        int val_;
        for(i=index+1;i<length;i++) 
        {
            
            // System.out.println(" i  " +i);
            // System.out.println(" index  " +index);
            // val_ = i-index-1;
            // System.out.println(" val_  " +val_);
            // System.out.println(" length  " +length);

            right_in[i-index-1] = inorder[i];
            

        }

        int[] left_post = new int[index];
        for(i=0;i<index;i++) left_post[i] = postorder[i];

        int[] right_post = new int[length-1-index];
        for(i=index;i<length-1;i++) right_post[i-index] = postorder[i];

        root.left = buildTree(left_in,left_post);
        root.right =buildTree(right_in,right_post);


        return root;

    }
}