LeetCode - 解题笔记 - 95 - Unique Binary Search Trees II-优快云博客

本文链接：https://blog.youkuaiyun.com/cary_leo/article/details/120309325

这篇博客详细探讨了解决LeetCode第95题的独特方法，通过深度优先搜索策略来构造唯一二叉搜索树。作者分析了两种解决方案，强调了在构建过程中保证BST性质的重要性，并指出时间复杂度与空间复杂度均与第n个卡特兰数相关。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Solution 1

根据BST的要求，我们需要保证所有左子树中节点的值小于根节点，所有右子树中节点大于根节点。所以我们在向下搜索的过程中记录当前可选择数字的范围就可以了。向下构造子树的过程中，不断枚举子树的根节点，然后确定两个子树可枚举范围就可以了。向上回溯时，对所有的左右子树进行排列组合就可以了。

时间复杂度： $O(nG_n)$ ，其中 $n$ 为输入的数字（树中节点个数）， $G_n$ 为第 $n$ 个卡特兰数（划重点！）
空间复杂度： $O(nG_n)$ ，其中 $n$ 为输入的数字（树中节点个数）， $G_n$ 为第 $n$ 个卡特兰数

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        return this->generate(1, n);
    }
private:
    vector<TreeNode*> generate(int start, int end) {\
        // cout << start << " " << end << endl;
        if (start > end) { return {nullptr}; }
        vector<TreeNode*> subTrees;
        for (int i = start; i <= end; ++i) {
            vector<TreeNode*> subTreesLeft = this->generate(start, i - 1);
            vector<TreeNode*> subTreesRight = this->generate(i + 1, end);
            
            for (auto & subTreeLeft: subTreesLeft) {
                for (auto & subTreeRight: subTreesRight) {
                    TreeNode * cur = new TreeNode(i);
                    cur->left = subTreeLeft;
                    cur->right = subTreeRight;
                    subTrees.push_back(cur);
                }
            }
        }
        
        return subTrees;
    }
};

Solution 2

Solution 1的Python实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def generateTrees(self, n: int) -> List[Optional[TreeNode]]:
        return self.generate(1, n)
    
    def generate(self, start: int, end: int) -> List[Optional[TreeNode]]:
        if start > end: return [None]
        
        subTrees = list()
        for i in range(start, end + 1):
            subTreesLeft = self.generate(start, i - 1)
            subTreesRight = self.generate(i + 1, end)
            
            for subTreeLeft in subTreesLeft:
                for subTreeRight in subTreesRight:
                    cur = TreeNode(i)
                    cur.left = subTreeLeft
                    cur.right = subTreeRight
                    subTrees.append(cur)
                    
        return subTrees