力扣刷题Day17

最新推荐文章于 2024-09-14 18:52:56 发布

Ade-My，自由

最新推荐文章于 2024-09-14 18:52:56 发布

阅读量152

点赞数

分类专栏： leetcode刷题文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/witch2026/article/details/127989554

版权

leetcode刷题专栏收录该内容

21 篇文章 0 订阅

订阅专栏

654.最大二叉树

题目：力扣

这道题主要是需要理解最大二叉树的定义，题倒是不难。

先找到最大的节点为根节点，左孩子为数组最大值index左侧的最大值；右孩子为数组最大值index右侧的最大值 --- 以此递归。

因此很容易发现这道题是用前序遍历在递归的 - 先构造根节点，再去构造根节点的左右节点。

递归三部曲：

输入和输出：输入（数组，左边界，右边界）；输出（根节点 root）
终止条件：1.左边界大于右边界 - 空节点；2.左边界等于右边界，此时数组中只有一个元素 - nums[left]
单层递归逻辑：找到左右边界中数组的最大值，然后创造中间节点，然后递归创造左孩子，递归创造右孩子。

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return helper(nums, 0, nums.length -1);

    }

    public TreeNode helper(int[] nums, int left, int right){
        //终止条件
        if(left > right){
            return null;
        }

        if(right - left == 0){
            return new TreeNode(nums[left]);
        }

        //找到最大值
        int maxValue = 0;
        int index = 0;
        for(int i=left; i<=right; i++){
            if(nums[i] > maxValue){
                maxValue = nums[i];
                index = i;
            }
        }

        TreeNode root = new TreeNode(maxValue);//中间节点

        root.left = helper(nums, left, index-1);//左
        root.right = helper(nums, index+1, right);//右
       
       return root;
    }
}

参考资料：代码随想录

617.合并二叉树

题目：力扣

这道题仍然是用前序遍历来重新构造一颗二叉树。而这里可能会有的思考是：如何遍历两颗二叉树呢？

其实就是和遍历一颗是一样的，这里输入中让入的是两颗二叉树的节点。

递归逻辑：

输入输出：输入（根节点1，根节点2）；输出（新二叉树的根节点）
终止条件：如果根节点1和根节点2都为空 -- 返回空；如果根节点1为空，根节点2不为空，那么返回根节点2；如果根节点1不为空，根节点2为空，那么返回根节点1。
单层循环：放入新二叉树根节点的值（根节点1+根节点2的值），递归构造左孩子，递归构造右孩子

在进行实现的时候，纠结一种情况，就是加入根节点1是空的，而根节点2并不是叶子节点，也就是意味着可以根节点2 处有左孩子和右孩子，那么这样是不是需要继续递归根节点2之后的节点，把新的子树构造出来？

因此我刚开始是分了三种情况进行递归的：

 public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        //终止条件
        if(root1 == null && root2 == null){
            return null;
        }

        //中间节点的值
        int value = 0;
        if(root1 == null && root2 != null){
            value = root2.val;
        }else if(root1 != null && root2 == null){
            value = root1.val;
        }else{
            value = root1.val + root2.val;
        }
        TreeNode root = new TreeNode(value);

        //分三种情况进行递归
        if(root1 == null && root2 != null){
            root.left = mergeTrees(root1, root2.left);//左
            root.right = mergeTrees(root1, root2.right);//右
        }else if(root1 != null && root2 == null){
            root.left = mergeTrees(root1.left, root2);
            root.right = mergeTrees(root1.right, root2);
        }else{
            root.left = mergeTrees(root1.left, root2.left);
            root.right = mergeTrees(root1.right, root2.right);
        }
        
        return root;
    }

但是，二叉树的储存方式其实和链表是有点像的；如果根节点1是空的，而根节点2并不是叶子节点 -->意味着这个地方只要指向了根节点2，根节点2的左右子树也都被纳入新的二叉树中【根节点2处存在两个指针指向它，一个是原来根节点2的二叉树，一个是新的二叉树】。那么这样的话就不需要对根节点2的左右子树进行递归取值构造新的二叉树。

public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        //终止条件
        if(root1 == null && root2 == null){
            return null;
        }
        if(root1 != null && root2 == null){
            return root1;
        }
        if(root1 == null && root2 != null){
            return root2;
        }

        //中间节点的值
        int value = root1.val + root2.val;
        TreeNode root = new TreeNode(value);

        root.left = mergeTrees(root1.left, root2.left);
        root.right = mergeTrees(root1.right, root2.right);
        
        return root;
    }

参考资料：代码随想录

700.二叉搜索树中的搜索

题目：力扣

这道题逻辑其实很简单。

采用前序遍历的方式。

递归逻辑：

输入和输出：输入（根节点，目标值）；输出目标节点[值和目标值一样]/null
终止条件：如果根节点为空，那么返回空；如果根节点的值和目标值一样，则返回根节点
单层逻辑：如果目标值比根节点小，则遍历根节点左侧；如果目标值比根节点大，则遍历根节点右侧

在实现的时候需要注意的是：

这里递归的时候是有输出的 -- TreeNode；因此需要用TreeNode这个类进行储存结果

写递归函数的时候习惯直接写 searchBST(root->left, val)，却忘了递归函数还有返回值。

递归函数的返回值是什么? 是左子树如果搜索到了val，要将该节点返回。如果不用一个变量将其接住，那么返回值不就没了。

所以要 result = searchBST(root->left, val)。

代码实现：

public TreeNode searchBST(TreeNode root, int val) {
        //终止条件
        if(root == null){
            return null;
        }
        if(root.val == val){
            return root;
        }

        TreeNode result = null;
        if(val < root.val){
            result = searchBST(root.left, val);
        }else{
            result = searchBST(root.right, val);
        }

        return result;
    }

使用迭代法：

class Solution {
    // 迭代，利用二叉搜索树特点，优化，可以不需要栈
    public TreeNode searchBST(TreeNode root, int val) {
        while (root != null)
            if (val < root.val) root = root.left;
            else if (val > root.val) root = root.right;
            else return root;
        return null;
    }
}

参考资料：代码随想录

98.验证二叉搜索树

题目：力扣

在做的时候很容易想到的递归逻辑是，递归判断根节点的左边比根节点小，根节点的右边比根节点大。

public boolean isValidBST(TreeNode root) {
        //终止条件
        if(root == null){
            return true;
        }
        if(root != null && root.left !=null && root.val <= root.left.val){
            return false;
        }
        
        if(root != null && root.right !=null && root.val >= root.right.val){
            return false;
        }

        if(root.left != null){
            if(isValidBST(root.left)){
                return true;
            }
        }

        if(root.right != null){
            if(isValidBST(root.right)){
                return true;
            }
        }

        return true;
        
    }

但是并没有通过所有的用例：

二叉树并不是单纯这个条件 - 左孩子小于根节点，右孩子大于根节点

还有另一个条件 - 二叉树的左子树是一个有效二叉树，二叉树的右子树是一个有效二叉树。

因此如果是这种情况，那么之前判断的条件就不够了。

二叉搜索树

途中例子，实际上是不符合二叉树的规律的，但是在之前的判断中会被认为是合法的二叉树，

那么怎么判断左右子树都符合呢？

利用根节点增加上下界。

比如对于6这个节点，其实它的上界是15；下届是10，因此这个位置不能是6.

初始化的时候 - 对于左侧上界是根节点，下届是最小值；对于右侧下界是根节点，上界是最小值。

每次递归的时候，对于左侧就会更新上界，而对于右侧则会更新下届。

这里使用的是前序遍历方式；

在进行实现的时候需要注意：节点的长度范围在32位 - 因此采用Integer整型作为初始最大和最小值是不能够对比的，因此需要使用Long整型<注意编译的时候的类型转换>。

代码实现：

  public boolean isValidBST(TreeNode root) {
        return isValidBSTHelper(root, Long.MAX_VALUE, Long.MIN_VALUE);
        
    }

     public boolean isValidBSTHelper(TreeNode root, Long upperBound, Long LowerBound) {
         //终止条件
        if(root == null){
            return true;
        }

        if(root.val <= LowerBound || root.val >= upperBound){//中间节点
            return false;
        }

        boolean left = isValidBSTHelper(root.left, (long) root.val, LowerBound);//左
        boolean right = isValidBSTHelper(root.right, upperBound, (long) root.val);//右
        
        return left && right;
     }

而如果用中序遍历，且将二叉树的数值储存到一个数组中，那么这个数组是一个单调递增的数组。

因此一个最基本的想法就是

中序遍历二叉树，储存到数组中
判断数组是否单调递增

那么可以进行的优化就是：不采用数组，直接中序遍历二叉树是否单调递增。

这样就需要一个全局变量 - 储存当前最大值；遍历到一个节点就比较是否大于最大值，如果比最大值小说明二叉树不合法。

代码实现：

class Solution {
    Long maxValue = Long.MIN_VALUE;//当前最大值
    public boolean isValidBST(TreeNode root) {
        //终止条件
        if(root == null){
            return true;
        }

        //左节点
        boolean left = isValidBST(root.left);
        if(left != true) return false;

        //中间节点
        if(root.val <= maxValue){
            return false;
        }
        maxValue = (long) root.val;//更新最大值

        //右节点
        boolean right = isValidBST(root.right);
        return right;//遍历到最后是右边节点 - 直接返回就行
    }

}

参考资料：代码随想录