leetcode【中等】105、从前序和中序遍历构造二叉树 / 654、最大二叉树

最新推荐文章于 2024-02-20 09:21:03 发布

qq_40707462

最新推荐文章于 2024-02-20 09:21:03 发布

阅读量85

点赞数

分类专栏： leetcode 文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_40707462/article/details/114315734

版权

leetcode 专栏收录该内容

202 篇文章 2 订阅

订阅专栏

105、从前序和中序遍历构造二叉树

在这里插入图片描述
返回层序遍历：[3,9,20,null,null,15,7]

思路：递归
前序遍历：list[:1）左闭右开

    1              [1:idx+1)            [idx+1:)
[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]

中序遍历：

          [:idx)           idx           [idx+1:)
[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]

preorder第一个元素为root，在inorder里面找到root，在它之前的为左子树，之后为右子树。两边分别递归。

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if not preorder:
            return None
        rootval=preorder[0]#提取根节点
        root=TreeNode(rootval)
        idx=inorder.index(rootval)

        root.left=self.buildTree(preorder[1:idx+1],inorder[:idx])
        root.right=self.buildTree(preorder[idx+1:],inorder[idx+1:])
        
        return root

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length==0) return null;
        int rootval=preorder[0];
        TreeNode root=new TreeNode(rootval);
        int idx=0;
        for(int i=0;i<inorder.length;i++){
            if(rootval==inorder[i]){
                idx=i;
                break;
            }
        }
        int[] preorderLeft = Arrays.copyOfRange(preorder, 1, 1 + idx);
        int[] preorderRight = Arrays.copyOfRange(preorder, 1 + idx, preorder.length);

        int[] inorderLeft = Arrays.copyOfRange(inorder, 0, idx);
        int[] inorderRight = Arrays.copyOfRange(inorder, idx + 1, inorder.length);

        root.left=buildTree(preorderLeft,inorderLeft);
        root.right=buildTree(preorderRight,inorderRight);
        return root;
    }
}

654、最大二叉树

在这里插入图片描述

递归停止条件：nums.length==1
步骤：①找到最大值作为root
②递归左右

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        TreeNode root=new TreeNode();
        if(nums.length==1){
            root.val=nums[0];
            return root;
        }
        int maxv=nums[0];
        int maxidx=0;
        for(int i=1;i<nums.length;i++){
            if(nums[i]>maxv){
                maxv=nums[i];
                maxidx=i;
            }
        }
        root.val=maxv;

        if(maxidx>0){
            int[]left=Arrays.copyOfRange(nums,0,maxidx);
            root.left=constructMaximumBinaryTree(left);
        }
        if(maxidx<nums.length-1){
            int[]right=Arrays.copyOfRange(nums,maxidx+1,nums.length);
            root.right=constructMaximumBinaryTree(right);
        }
        return root;
    }
}