代码随想录第二十天

Save_Faith

已于 2022-10-12 22:02:07 修改

阅读量1.9k

点赞数

文章标签： leetcode 算法数据结构

于 2022-10-12 21:59:55 首次发布

本文链接：https://blog.csdn.net/savemyselfa/article/details/127291704

版权

内容：

最大二叉树(654)
合并二叉树(617)
二叉搜索树中的搜索(700)
验证二叉搜索树(98)

1. 最大二叉树

难度：🔥🔥🔥

建议：又是构造二叉树。先看视频，好好体会一下为什么构造二叉树都是前序遍历

1.1 思路分析

采用前序遍历，找到最大数的索引位置。以这个数为中间节点，然后递归构造左子树和右子树。

如图：

1.2 代码实现

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        //左闭右开，right = nums.length
        TreeNode node = constructMaximumBinaryTreeMethod(nums,0,nums.length);
        return node;
    }
    //直接使用数组下标进行操作
    private TreeNode constructMaximumBinaryTreeMethod(int[] nums,int left,int right){
        //特殊情况处理逻辑
        if (right - left < 1) {//没有元素
            return null;
        }
        if(right - left == 1){//只有一个元素
            return new TreeNode(nums[left]);
        }
        int maxIndex = left;//假定最大索引为left
        //i小于right 而不是nums.length
        for(int i = left + 1;i < right;i++){
            if(nums[i] > nums[maxIndex]){
                maxIndex = i;
            }
        }
        TreeNode root = new TreeNode(nums[maxIndex]);
        //[left,maxIndex)
        root.left = constructMaximumBinaryTreeMethod(nums,left,maxIndex);

        root.right = constructMaximumBinaryTreeMethod(nums,maxIndex + 1,right);

        return root;

    }
}

1.3 注意事项

这道题目我们统一使用左闭右开的区间规则，在递归构建左右子树时需要注意left和right的值

1.4 收获总结

2.合并二叉树

难度：🔥🔥

建议：这次是操作两个二叉树了，可以先看视频理解一下，优先掌握递归

2.1 思路分析

本题使用何种遍历方式都是可以的。当然前序遍历是最好理解的

并且我们直接使用root1作为我们的结果。

使用递归三部曲即可解决这道题目。

2.2 代码实现

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        //当两个节点分别为空时，返回另一个节点
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {
            return root1;
        }
        //前序遍历,并且我们直接使用root1作为我们的结果
        //中
        root1.val += root2.val;
        //左
        root1.left = mergeTrees(root1.left,root2.left);
        //右
        root1.right = mergeTrees(root1.right, root2.right);

        return root1;
    }
}

2.3 注意事项

2.4 收获总结

3. 二叉搜索树中的搜索

难度：🔥🔥

建议：递归和迭代都可以掌握一下，因为本题较简单，了解一下二叉搜索树的特性

3.1 思路分析

根据二叉搜索树的特性可以让我们轻松搜索到我们想要的值

3.2 代码实现

递归

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {   
		if (root == null || root.val == val) {
            return root;
        }
        TreeNode result = null;
        if (root.val < val) {
            return searchBST(root.right,val);
       }else{
            return searchBST(root.left,val);
        }
    }
}

迭代

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
		while (root != null) {
            if (root.val < val) {
                root = root.right;
            }
            else if (root.val > val) {
                root = root.left;
            }else return root;
        }
        return null;
    }
}

3.3 注意事项

3.4 收获总结

4.验证二叉搜索树

难度：🔥🔥🔥

建议：遇到搜索树，一定想着中序遍历，这样才能利用上特性。但本题是有陷阱的，可以自己先做一做，然后再看题解，看看自己是不是掉进陷阱了。这样理解的更加深刻

4.1 思路分析

采用中序遍历是这题的关键。

在中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

4.2 代码实现

class Solution {
    private long pre = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
        //按照中序遍历
        if (root == null) {
            return true;
        }
        boolean left = isValidBST(root.left);
        //左
        if (!left) {
            return false;
        }
        //中
        if (root.val <= pre) {
            return false;
        }
        pre = root.val;
		//右
        return isValidBST(root.right);
    }
}