代码随想录算法训练营第18天｜513.找树左下角的值、110.路径总和、106.从总序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树

最新推荐文章于 2024-09-12 19:02:20 发布

Chauncey1995

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量374

点赞数

分类专栏：代码随想录算法营文章标签：算法数据结构 java

本文链接：https://blog.csdn.net/qq_33269525/article/details/127359038

版权

代码随想录算法营专栏收录该内容

32 篇文章 1 订阅

订阅专栏

代码随想录算法训练营第18天｜513.找树左下角的值、110.路径总和、106.从总序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树

一. 二叉树相关算法题

一. 二叉树相关算法题

513.找树左下角的值

层序遍历-迭代

思路

层序遍历到最后一行然后找最左边节点的值
至于怎么找最左边的值可以在层序遍历的时候先入队列右叶子节点，再入队列左叶子节点
那么再每层队列遍历时队列最后一个就是左节点

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        //层序遍历
        Deque<TreeNode> deque = new LinkedList<>();
        if (root != null) deque.push(root);
        int res = 0;
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size-->0) {
                TreeNode node = deque.pollLast();
                // 先入队列右叶子可以保证每层队列最后一位就是每层的左下角
                if (node.right != null) deque.push(node.right);
                if (node.left != null) deque.push(node.left);
                if (size==0) {
                    res = node.val;
                }
            }
        }
        return res;
    }
}

递归

思路

保证左边搜索同时记录深度最大的叶子节点
递归三部曲：
- 递归参数和返回值：当前节点，上一轮最长深度；返回值为void
- 递归终止条件：遇到叶子节点更新最大深度和返回值
- 单层逻辑：先搜索左叶子再搜索右叶子
具体代码如下

class Solution {

    private int maxDepth = Integer.MIN_VALUE;
    private int result;
    public int findBottomLeftValue(TreeNode root) {
        getLeft(root,0);
        return result;
    }

    public void getLeft(TreeNode cur, int depth){
        //递归终止条件
        if (cur.left == null && cur.right == null) {
            // depth已经在上轮递归中加1了
            if (maxDepth<depth){
                maxDepth = depth;
                result = cur.val;
            }
        }

        //注意一定要先访问左子树，因为要保证从左边搜索
        if (cur.left != null) {
            depth++;
            getLeft(cur.left, depth);
            depth--; //回溯
        }
        if (cur.right != null) {
            depth++;
            getLeft(cur.right, depth);
            depth--; //回溯
        }

    }
}

110.路径总和

递归

思路

没有设计到根节点的处理所以前中后序都可以
本题可以根据深度优先遍历从根节点出发将targetSum逐级减去当前节点的值如果到叶子节点target减为0直接返回true
递归三要素:
1. 确定递归函数的参数和返回类型
  2. 参数:需要知道当前节点,还需要累加路径节点之和
  3. 返回值应该为布尔值因为只要一出现target减为0的路径就返回true
2. 递归终止条件:当遇到target清零0需要返回true.反之到达根节点还没有清零返回false并回溯target
3. 单层递归逻辑:
  4. 因为终止条件是判断叶子节点所以要控制不让叶子节点进入递归,并且在进入下轮递归前先计算出target
  5. 判断左右子树是否返回true如果为true直接返回
  6. 否则回溯target的值

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null) return false;
        return getPathSum(root,targetSum - root.val); //进入递归函数前先减去当前节点的值
    }

    public boolean getPathSum(TreeNode cur, int count){
        //计算叶子节点不用把空节点加入递归
        // 遍历节点的同时将target减去节点的值如果到达叶子节点且target减到0就返回true
        if (cur.left == null && cur.right == null && count == 0) return true;
        // 如果到叶子节点且target没有归0 返回false
        if (cur.left == null && cur.right == null) return false;

        // 单层递归逻辑
        if (cur.left != null) {
            count = count - cur.left.val; //进入递归函数前先减去当前节点的值
            //如果叶子节点返回true 直接返回true
            if (getPathSum(cur.left, count)) return true;
            // 如果叶子节点返回false 回溯
            count = count + cur.left.val;
        }
        if (cur.right != null) {
            count = count - cur.right.val; //进入递归函数前先减去当前节点的值
            //如果叶子节点返回true 直接返回true
            if (getPathSum(cur.right, count)) return true;
            // 如果叶子节点返回false 回溯
            count = count + cur.right.val;
        }

        //如果左右叶子节点都没有得到结果
        // 直接返回false
        return false;
    }
}

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

思路

可以先从后续队列最后一个元素确定根节点
然后通过根节点确认在中序序列的位置,通过此根节点在中序序列的位置拆分出左右子序列
根据中序左右子序列的长度拆分后序的左右子序列
大致可以分为6步

第一步：如果数组大小为零的话，说明是空节点了。
第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）
第五步：切割后序数组，切成后序左数组和后序右数组，
第六步：递归处理左区间和右区间

具体代码如下

class Solution {
    Map<Integer,Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        //因为题目中说节点数值不相等，可以通过Map缓存中序数组中节点数值对应的下标
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i],i);
        }
        //左闭右开，右边就直接是数组长度
        return getRoot(inorder,0, inorder.length, postorder, 0, postorder.length);
    }

    public TreeNode getRoot(int[] inorder,int instart,int inend, int[] postorder, int postStart, int postEnd) {
        // 第一步：如果数组大小为零的话，说明是空节点了。
        if (postStart == postEnd) return null;
        // 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
        int rootValue = postorder[postEnd-1]; //左闭右开所以要减一获取
        TreeNode root = new TreeNode(rootValue);
        if ( postEnd-postStart == 1) return root;
        // 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
        int rootIndex = map.get(rootValue);
        // 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
        // 这里切割时就体现了左闭右开的好处：不用处理根节点,不用对长度计算减一得到末位索引
        //中序左数组
        int inorderLeftStart = instart;
        int inorderLeftEnd = rootIndex;
        //中序右数组
        int inOrderRightStart = rootIndex+1;
        int inOrderRightEnd = inend;

        // 第五步：切割后序数组，切成后序左数组和后序右数组，
        // 切割后的左右子数组一定等与中序的左右子数组，所以后序数组的左右子数组通过中序左右子数组长度确定
        int postOrderLeftStart = postStart;
        //子数组长度等于中序子数组长度 左闭右开所以不用考虑减一
        int postOrderLetfEnd = postStart+inorderLeftEnd-inorderLeftStart;
        int postOrderRightStart = postOrderLetfEnd;
        //同样根据中序子数组长度计算
        int postOrderRightEnd = postOrderRightStart+inOrderRightEnd-inOrderRightStart;

        // 第六步：递归处理左区间和右区间
        root.left = getRoot(inorder,inorderLeftStart,inorderLeftEnd,postorder,postOrderLeftStart,postOrderLetfEnd);
        root.right = getRoot(inorder,inOrderRightStart,inOrderRightEnd,postorder,postOrderRightStart,postOrderRightEnd);
        return root;
    }

}

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

思路

与后序相反：通过前序第一个节点确定根节点

第一步：如果数组大小为零的话，说明是空节点了。
第二步：如果不为空，那么取前序数组第一个元素作为节点元素。
第三步：找到前序数组第一个元素在中序数组的位置，作为切割点
第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组），使用左闭右开的话有边界直接就是根节点下标和数组长度
第五步：切割前序数组，切成前序左数组和前序右数组，
第六步：递归处理左区间和右区间

class Solution {
    Map<Integer,Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        //因为题目中说节点数值不相等，可以通过Map缓存中序数组中节点数值对应的下标
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i],i);
        }
        //左闭右开，右边就直接是数组长度
        return getRoot(inorder,0, inorder.length, preorder, 0, preorder.length);
    }

    public TreeNode getRoot(int[] inorder,int instart,int inend, int[] postorder, int postStart, int postEnd) {
        // 第一步：如果数组大小为零的话，说明是空节点了。
        if (postEnd==postStart) return null;
        // 第二步：如果不为空，那么取前序数组第一个元素作为节点元素。
        int rootValue = postorder[postStart];
        TreeNode root = new TreeNode(rootValue);
        if (postEnd-postStart==1) return root;
        // 第三步：找到前序数组第一个元素在中序数组的位置，作为切割点
        int rootIndex = map.get(rootValue);
        // 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
        // 这里切割时就体现了左闭右开的好处：不用处理根节点,不用对长度计算减一得到末位索引
        //中序左数组
        int inorderLeftStart = instart;
        int inorderLeftEnd = rootIndex; //左闭右开
        //中序右数组
        int inOrderRightStart = rootIndex+1;
        int inOrderRightEnd = inend;
        // 第五步：切割前序数组，切成前序左数组和前序右数组，
        int postOrderLeftStart = postStart+1; //左闭右开
        // 切割后的左右子数组一定等与中序的左右子数组，所以后序数组的左右子数组通过中序左右子数组长度确定
        int postOrderLetfEnd = postOrderLeftStart+inorderLeftEnd-inorderLeftStart;
        //子数组长度等于中序子数组长度 左闭右开所以不用考虑减一
        int postOrderRightStart = postOrderLetfEnd;
        //同样根据中序子数组长度计算
        int postOrderRightEnd = postEnd;

        // 第六步：递归处理左区间和右区间
        root.left = getRoot(inorder,inorderLeftStart,inorderLeftEnd,postorder,postOrderLeftStart,postOrderLetfEnd);
        root.right = getRoot(inorder,inOrderRightStart,inOrderRightEnd,postorder,postOrderRightStart,postOrderRightEnd);
        return root;
    }
}