随想录刷题笔记 —二叉树篇6 513找树左下角的值 112路径总和 106中序后序构造二叉树

最新推荐文章于 2024-06-24 16:18:42 发布

XWHQQ7426

最新推荐文章于 2024-06-24 16:18:42 发布

阅读量420

点赞数 9

分类专栏：随想录刷题文章标签：笔记数据结构算法 java leetcode

本文链接：https://blog.csdn.net/weixin_44936793/article/details/136131934

版权

随想录刷题专栏收录该内容

22 篇文章 0 订阅

订阅专栏

513找树左下角的值

找出该二叉树的 最底层最左边 节点的值

解法一：队列——层次遍历

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> treeNodes = new LinkedList<>();
        treeNodes.offer(root);
        int count = 1;
        int result = root.val;
        while (!treeNodes.isEmpty()){
            TreeNode temp = treeNodes.poll();
            count--;
            if (temp.left!=null){
                treeNodes.offer(temp.left);
            }
            if (temp.right!=null){
                treeNodes.offer(temp.right);
            }
            if (count==0){
                if (!treeNodes.isEmpty()){
                    result = treeNodes.peek().val;
                }
                count = treeNodes.size();
            }
        }
        return result;
    }
}

解法二：递归

设置maxdepth变量，记录最大深度。

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        fBLValue(root, 1);
        return resultval;
    }
    int maxdepth = 0;
    int resultval = 0;
    void fBLValue(TreeNode root, int depth) {
        if (root.right==null&&root.left==null){
            if (maxdepth<depth){
                resultval=root.val;
                maxdepth=depth;
            }
            return;
        }
        if (root.left!=null){
            fBLValue(root.left, depth+1);
        }
        if (root.right!=null){
            fBLValue(root.right, depth+1);
        }
    }
}

112路径总和

是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum

递归：传入参数value，表示从根节点到此节点的路径值。

当结点是叶子节点时，计算路径值是否=targetSum

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root==null){
            return false;
        }
        return hasPathS(root, targetSum, 0);
    }
    boolean hasPathS(TreeNode root, int targetSum, int value) {
        if (root==null){
            return false;
        }
        if (root.right==null&&root.left==null){
            return value + root.val == targetSum;
        }
        return hasPathS(root.left, targetSum, value+root.val)||hasPathS(root.right, targetSum, value+root.val);
        }
}

106中序后序构造二叉树

递归：以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。

一层一层切下去，每次后序数组最后一个元素就是节点元素。

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        TreeNode root = new TreeNode(postorder[postorder.length-1], null, null);
        int mid = findindex(inorder, postorder[postorder.length-1], 0, inorder.length-1);
        if (mid!=0){
            root.left = buildTree(Arrays.copyOfRange(inorder, 0, mid), Arrays.copyOfRange(postorder, 0, mid));
        }
        if (mid!=inorder.length-1){
            root.right = buildTree(Arrays.copyOfRange(inorder, mid+1, inorder.length), Arrays.copyOfRange(postorder, mid, postorder.length-1));
        }
        return root;
    }

    int findindex(int[] order, int value, int left, int right){
        for (int i = left; i <= right; i++) {
            if (value==order[i]){
                return i;
            }
        }
        return -1;
    }
}