7月11日的五题

最新推荐文章于 2022-06-28 14:28:03 发布

lwycc233

最新推荐文章于 2022-06-28 14:28:03 发布

阅读量173

点赞数

分类专栏：刷题第一轮

本文链接：https://blog.csdn.net/lwycc2333/article/details/107289760

版权

刷题第一轮专栏收录该内容

16 篇文章 0 订阅

订阅专栏

95. 不同的二叉搜索树 II

Difficulty: 中等

给定一个整数 n，生成所有由 1 … n 为节点所组成的 二叉搜索树 。

示例：

输入：3
输出：
[
  [1,null,3,2],
  [3,2,null,1],
  [3,1,null,null,2],
  [2,1,3],
  [1,null,2,null,3]
]
解释：
以上的输出对应以下 5 种不同结构的二叉搜索树：

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

提示：

0 <= n <= 8

Solution：递归，以其中一个值为根节点，其两边的值就是左右子树，注意当 L > R时，需要添加null

/**
 * 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;
 *     }
 * }
 */


 /*思路：
        1. 就是把L,R看成是二叉搜索树中序遍历的左右边界
        2.枚举每个点为root，递归两边。返回的集合中都是合法的左子树或者右子树
        3.root和集合中的左右子树分别拼接一下即可
*/

class Solution {
     public List<TreeNode> generateTrees(int n) {
        
        if(n < 1) return new ArrayList<>();
        return dfs(1,n);
    }


    public List<TreeNode> dfs(int L, int R){
        List<TreeNode> res = new ArrayList<>();
        if(L > R){
            res.add(null);
            return res;
        }

        for(int i=L; i<=R; i++){  //分别为根节点
            
            List<TreeNode> left = dfs(L, i-1);
            List<TreeNode> right = dfs(i+1, R);
            for(TreeNode l: left){
                for(TreeNode r: right){
                    TreeNode head = new TreeNode(i);
                    head.left = l;
                    head.right = r;
                    res.add(head);
                }
            }
        }
        return res;
    }
   

}

96. 不同的二叉搜索树

Difficulty: 中等

给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？

示例:

输入: 3
输出: 5
解释:
给定 n = 3, 一共有 5 种不同结构的二叉搜索树:

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

Solution：对比上一题。找规律 :

当n = 3时：

以1根节点 f(3) += f(0)*f(2)
以2为根节点：f(3) += f(1)*f(1)
以3位根结点：f(3) += f(2)*f(0)
其中f(0) = 1，f(1) = 1, f(2) = 2；所以f(3) = f(0)*f(2) + f(1)*f(1) + f(2)*f(0) = 5
同理 f(4) = f(0)*f(3) + f(1)*f(2) + f(2)*f(1) + f(3)*f(0) = 14
f(n) = f(0)*f(n-1) + f(1)*f(n-2) + f(2)*f(n-3) +…+ f(n-1)*f(0)

class Solution {
    public int numTrees(int n) {

        if(n<=0) return 0;
        if(n == 1) return 1;
        if(n == 2) return 2;

        int[] dp = new int[n+1];
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;
        
        for(int i=3; i<=n; i++){
            dp[i] = 0;
            for(int j=0; j<=i-1; j++){
                dp[i] += dp[j]*dp[i-1-j];
            }
        }
        return dp[n];
    }


}

97. 交错字符串

Difficulty: 困难

给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。

示例 1:

输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
输出: true

示例 2:

输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
输出: false

Solution：动态规划，boolean dp[i][j]表示s1的前i个字符，s2的前j个字符，是否可以组合成s3的前（i+j）个字符

class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        
        int len1 = s1.length(), len2 = s2.length(), len3 = s3.length();
        if(len3<0 || (len1+len2)!=len3) return false;

        boolean[][] dp = new boolean[len1+1][len2+1];
        dp[0][0] = true;

        for(int i=0; i<=len1; i++){
            for(int j=0; j<=len2; j++){
                if(i==0 && j==0) continue;
                else if(i==0){
                    if(s2.charAt(j-1) == s3.charAt(j-1)) dp[0][j] = dp[0][j-1];
                }
                else if(j==0){
                    if(s1.charAt(i-1) == s3.charAt(i-1)) dp[i][0] = dp[i-1][0];
                }
                else{
                    dp[i][j] = (s1.charAt(i-1)==s3.charAt(i+j-1) && dp[i-1][j]) || 
                                (s2.charAt(j-1)==s3.charAt(i+j-1) && dp[i][j-1]);
                }
            }
        }
        return dp[len1][len2];

    }

}

98. 验证二叉搜索树

Difficulty: 中等

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1:

输入:
    2
   / \
  1   3
输出: true

示例 2:

输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。

Solution：中序遍历是否递增，非递归遍历（借助栈）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        List<Integer> num = new ArrayList<>();
        List<TreeNode> stack = new ArrayList<>();

        TreeNode cur = root;
        while(cur!=null || !stack.isEmpty()){
            if(cur != null){
                stack.add(cur);
                cur = cur.left;
            }
            else{
                cur = stack.remove(stack.size()-1);
                if(!num.isEmpty() && num.get(num.size()-1) >= cur.val) 
                    return false;
                num.add(cur.val);
                cur = cur.right;
            }
        }
        return true;
    }
}

99. 恢复二叉搜索树

Difficulty: 困难

二叉搜索树中的两个节点被错误地交换。

请在不改变其结构的情况下，恢复这棵树。

示例 1:

输入: [1,3,null,null,2]

   1
  /
 3
  \
   2

输出: [3,1,null,null,2]

   3
  /
 1
  \
   2

示例 2:

输入: [3,1,4,null,null,2]

  3
 / \
1   4
   /
  2

输出: [2,1,4,null,null,3]

  2
 / \
1   4
   /
  3

进阶:

使用 O(n) 空间复杂度的解法很容易实现。
你能想出一个只使用常数空间的解决方案吗？

Solution：中序遍历之后，找到逆序对，如果只有一对，则两个数直接交换，如果有两对，则交换这两对数最左边和最右边。

/**
 * 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 void recoverTree(TreeNode root) {
        if(root == null) return;
        List<TreeNode> nodeList = new ArrayList<>();
        midSort(root, nodeList);


        int i1 = 0, i2 = 0; //需要交换的位置
        int count = 0; //逆序对的个数
        int len = nodeList.size();
        for(int i=0; i<len; i++){
            if(i<len-1 && nodeList.get(i).val>nodeList.get(i+1).val){
                if(count == 0){
                    i1 = i;
                    i2 = i+1;
                    count++;
                }
                else{
                    i2 = i+1;
                    break;
                }
                //System.out.println(i1+","+i2);
            }
        }

        //System.out.println(nodeList.get(i1).val +","+ nodeList.get(i2).val);
        //交换值
        int temp = nodeList.get(i1).val;
        nodeList.get(i1).val = nodeList.get(i2).val;
        nodeList.get(i2).val = temp;
    }

   //中序遍历
    public void midSort(TreeNode root, List<TreeNode> nodeList){
        if(root == null) return;
        midSort(root.left, nodeList);
        nodeList.add(root);
        midSort(root.right, nodeList);
    }
}