力扣算法 Java 刷题笔记【二叉树篇】hot100（二）最大二叉树（中等）从前序与中序遍历序列构造二叉树（中等） 3

最新推荐文章于 2024-11-12 21:14:07 发布

心海非海_

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量454

点赞数 4

分类专栏：数据结构与算法文章标签： java 算法 leetcode 二叉树

本文链接：https://blog.csdn.net/weixin_46644403/article/details/121557482

版权

数据结构与算法专栏收录该内容

51 篇文章 7 订阅

订阅专栏

文章目录

1. 最大二叉树（中等）
2. 从前序与中序遍历序列构造二叉树（中等）
3. 从中序与后序遍历序列构造二叉树（中等）

1. 最大二叉树（中等）

地址: https://leetcode-cn.com/problems/maximum-binary-tree/
2021/11/30
做题反思：length

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return build(nums, 0, nums.length - 1);
    }
    
    TreeNode build(int[] nums, int lo, int hi) {
        if (lo > hi) {
            return null;
        }
        int index = -1, max = Integer.MIN_VALUE;
        for (int i = lo; i <= hi; i++) {
            if (nums[i] > max) {
                max = nums[i];
                index = i;
            }
        }

        TreeNode root = new TreeNode(max);
        root.left = build(nums, lo, index - 1);
        root.right = build(nums, index + 1, hi);
        return root;
    }
}

在这里插入图片描述

2. 从前序与中序遍历序列构造二叉树（中等）

2020 近半年在字节跳动算法面试环节出现过高达 14 次
地址: https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
2021/11/30
做题反思：

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return build(preorder, 0, preorder.length - 1,
            inorder, 0, inorder.length - 1);
    }

    TreeNode build(int[] preorder, int preStart, int preEnd,
        int[] inorder, int inStart, int inEnd) {
        
        if (preStart > preEnd || inStart > inEnd) {
            return null;
        }
        
        int rootVal = preorder[preStart];
        int index = 0;
        for (int i = inStart; i <= inEnd; i++) {
            if (inorder[i] == rootVal) {
                index = i;
                break;
            }
        }
        TreeNode root = new TreeNode(rootVal);
        int leftSize =  index - inStart;

        root.left = build(preorder, preStart + 1, preStart + leftSize,
            inorder, inStart, index - 1);
        root.right = build(preorder, preStart + leftSize + 1, preEnd,
            inorder, index + 1, inEnd);
        
        return root;
    }

在这里插入图片描述

3. 从中序与后序遍历序列构造二叉树（中等）

地址: https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
2021/11/30
做题反思：

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        return build(inorder, 0, inorder.length - 1,
            postorder, 0, postorder.length - 1);
    }

    TreeNode build(int[] inorder, int inStart, int inEnd,
        int[] postorder, int postStart, int postEnd) {
        
        if (inStart > inEnd || postStart > postEnd) {
            return null;
        }
                                                                                                    
        int rootVal = postorder[postEnd];
        int index = 0;
        for (int i = inStart; i <= inEnd; i++) {
            if (inorder[i] == rootVal) {
                index = i;
                break;
            }
        }

        TreeNode root = new TreeNode(rootVal);
        int leftSize = index - inStart;
        root.left = build(inorder, inStart, index - 1,
            postorder, postStart, postStart + leftSize - 1); 
        root.right = build(inorder, index + 1, inEnd,
            postorder, postStart + leftSize, postEnd - 1);
        
        return root;   
    }
}