CodeTop每日系列三题------------------2021.11.27

最新推荐文章于 2024-10-16 10:13:45 发布

破晓以胜

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量287

点赞数

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

本文链接：https://blog.csdn.net/weixin_44004649/article/details/121573779

版权

这篇博客介绍了两种解题方法，分别用于验证二叉搜索树的正确性和处理数组操作。第一部分展示了如何使用递归和迭代的方式来验证一个二叉树是否符合二叉搜索树的特性。第二部分则讨论了如何找到两个数组中最长的重复子数组，以及如何找出数组的所有子集。这些算法涉及到了二叉树的遍历和动态规划的运用。

摘要由CSDN通过智能技术生成

LC98. 验证二叉搜索树
在这里插入图片描述

//递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        return ValidBST(Long.MIN_VALUE,Long.MAX_VALUE,root);
    }

    boolean ValidBST(long lower,long upper, TreeNode root){
        if(root == null)
        return true;
        if(root.val <= lower|| root.val >= upper)
        return false;

        return ValidBST(lower,root.val,root.left) && ValidBST(root.val,upper,root.right);
    }
}

//迭代,中序遍历
class Solution {
    public boolean isValidBST(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        double inorder = -Double.MAX_VALUE;

        while (!stack.isEmpty() || root != null) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
              // 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if (root.val <= inorder) {
                return false;
            }
            inorder = root.val;
            root = root.right;
        }
        return true;
    }
}

在这里插入图片描述
LC718. 最长重复子数组
//和最长公共子序列题目类似也是通过一个二维的dp数组，然后求dp[m][n],正向遍历得到结果

class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        int result = 0;
        for(int i = 1;i <= nums1.length;i++){
            for(int j = 1;j <= nums2.length;j++){
                if(nums1[i - 1] == nums2[j - 1])
                dp[i][j] = dp[i - 1][j - 1] + 1;
                result = Math.max(result,dp[i][j]);
            }
        }
        return result;
    }
}

在这里插入图片描述
LC78. 子集
//和排列问题类似也是需要一个变量值去控制整个循环过程当中，此时子集的变量值是传递到for循环由for循环控制，并且我们不管是排列组合还是子集问题我们都是要在递归出口进行一个res最终值得一个添加操作res.add(new ArrayList(path));取一个镜像值因为如果不这么操作的话path加进去得时候永远是remove以后剩下一个空得list
在这里插入图片描述

class Solution {

    private LinkedList<Integer> path = new LinkedList();
    private List<List<Integer>> res = new ArrayList();

    public List<List<Integer>> subsets(int[] nums) {
        if(nums.length == 0)
        return res;
        backtrace(nums,0);
        return res;
    }

    public void backtrace(int[] nums,int idx){
        res.add(new ArrayList(path));

        for(int i = idx;i < nums.length;i++){
            path.add(nums[i]);
            //自己不重复,i+1
            backtrace(nums,i + 1);
            path.removeLast();
        }
    }
}