随想录Day18--513. 找树左下角的值,112. 路径总和,113. 路径总和 II,106. 从中序与后序遍历序列构造二叉树,105. 从前序与中序遍历序列构造二叉树

最新推荐文章于 2024-11-10 22:49:00 发布

石头走到哪里还是石头

最新推荐文章于 2024-11-10 22:49:00 发布

阅读量61

点赞数 1

文章标签：数据结构 leetcode java Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_46516575/article/details/129361396

版权

今天的题目大约覆盖了3种题型，513用传统的迭代法可以快速锁定到层数和层数中的第几个元素，因此思路比较清晰。路径总和实际上思路是一样的，递归遍历节点，找到叶子节点后，计算路径上的和是否等于目标值，如果不相等不进行操作，相等的话，把路径上的节点用list收集起来。构造二叉树用递归思路也是比较清晰，关键在于中序和其他顺序的配合，找到中间根节点后，扩展它的子节点。

513. 找树左下角的值

给定一个二叉树的根节点 root，请找出该二叉树的最底层最左边节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]

输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]

输出: 7

提示:

二叉树的节点个数的范围是 [1,104]

-231 <= Node.val <= 231 - 1

class Solution {
    //迭代法，找到最底层的第一个元素
    public int findBottomLeftValue(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        int result = 0;
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                if(i == 0){
                    result = node.val;
                }
            }
        }
        return result;
    }
}

112. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22

输出：true

解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5

输出：false

解释：树中存在两条根节点到叶子节点的路径：

(1 --> 2): 和为 3

(1 --> 3): 和为 4

不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0

输出：false

解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

树中节点的数目在范围 [0, 5000] 内

-1000 <= Node.val <= 1000

-1000 <= targetSum <= 1000

class Solution {
    //定义一个全局变量，如果找到根节点后，满足条件，可以返回true
    int flag = 0;
    public boolean hasPathSum(TreeNode root, int targetSum) {
        findWay(root, 0, targetSum);
        if(flag == 0){
            return false;
        }else{
            return true;
        }
    }
    public void findWay(TreeNode node, int sum, int targetSum){
        if(node == null){
            return;
        }
        if(node.left == null && node.right == null){
            if(sum + node.val == targetSum){
                flag = 1;
            }
        }
        if(node.left != null){
            findWay(node.left, sum + node.val, targetSum);
        }
        if(node.right != null){
            findWay(node.right, sum + node.val, targetSum);
        }
    }
}

113. 路径总和 II

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。

叶子节点是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22

输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5

输出：[]

示例 3：

输入：root = [1,2], targetSum = 0

输出：[]

提示：

树中节点总数在范围 [0, 5000] 内

-1000 <= Node.val <= 1000

-1000 <= targetSum <= 1000

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<Integer> list = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        findWay(root, targetSum, list, res);
        return res;
    }
     public void findWay(TreeNode node, int targetSum,List<Integer> list, List<List<Integer>> res){
        if(node == null){
            return;
        }
        list.add(node.val);
        if(node.left == null && node.right == null){
            if(targetSum - node.val == 0){
                res.add(new ArrayList<>(list));
            }
        }

        if(node.left != null){
            findWay(node.left, targetSum - node.val, list, res);
            list.remove(list.size() - 1);
        }
        if(node.right != null){
            findWay(node.right, targetSum - node.val, list, res);
            list.remove(list.size() - 1);
            
        }
    }
}

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

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

示例 1:

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]

输出：[3,9,20,null,null,15,7]

示例 2:

输入：inorder = [-1], postorder = [-1]

输出：[-1]

提示:

1 <= inorder.length <= 3000

postorder.length == inorder.length

-3000 <= inorder[i], postorder[i] <= 3000

inorder 和 postorder 都由不同的值组成

postorder 中每一个值都在 inorder 中

inorder 保证是树的中序遍历

postorder 保证是树的后序遍历

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;
    }
}

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

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

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]

输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]

输出: [-1]

提示:

1 <= preorder.length <= 3000

inorder.length == preorder.length

-3000 <= preorder[i], inorder[i] <= 3000

preorder 和 inorder 均无重复元素

inorder 均出现在 preorder

preorder 保证为二叉树的前序遍历序列

inorder 保证为二叉树的中序遍历序列

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

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