[LeetCode] Unique Binary Search Trees II

最新推荐文章于 2020-12-09 16:51:01 发布

原创最新推荐文章于 2020-12-09 16:51:01 发布 · 3.6k 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode1 专栏收录该内容

120 篇文章

订阅专栏

本文介绍了一种算法，用于生成所有可能的独特二叉搜索树（BST），这些树存储从1到n的值。通过递归地构造左右子树，并将它们连接到以不同整数为根的节点上，实现了这一目标。

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

[Problem]

Given n, generate all structurally unique BST's (binary search trees) that store values 1...n.

For example,
Given n = 3, your program should return all 5 unique BST's shown below.

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

[Analysis]
对于大小为n的BST，轮流让 i (0 <= i <= n) 作为根，当i为根时，左子树由1~i-1这些数组成，右子树由i+1~n这些数组成。

[Solution]

class Solution {
public:
    // generate trees between start and end
    vector<TreeNode *> generateTrees(int start, int end) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<TreeNode *> res;
   
        // null node
        if(start > end){
            res.push_back(NULL);
        }
        // root node
        else if(start == end){
            TreeNode *root = new TreeNode(start);
            res.push_back(root);
        }
        else{
            // root node could be 1~n
            for(int i = start; i <= end; ++i){
                // generate left brunch and right brunch
                vector<TreeNode *> leftTrees = generateTrees(start, i-1);
                vector<TreeNode *> rightTrees = generateTrees(i+1, end);
   
                // both left brunch and right brunch are null
                if(leftTrees.size() == 0 && rightTrees.size() == 0){
                    // create root node
                    TreeNode *root = new TreeNode(i);
                    res.push_back(root);
                }
                // left brunch is null
                else if(leftTrees.size() == 0){
                    for(int j = 0; j < rightTrees.size(); ++j){
                        // create root node
                        TreeNode *root = new TreeNode(i);
                        root->right = rightTrees[j];
                        res.push_back(root);
                    }
                }
                // right brunch is null
                else if(rightTrees.size() == 0){
                    for(int j = 0; j < leftTrees.size(); ++j){
                        // create root node
                        TreeNode *root = new TreeNode(i);
                        root->left = leftTrees[j];
                        res.push_back(root);
                    }
                }
                // both left brunch and right brunch are not null
                else{
                    for(int j = 0; j < leftTrees.size(); ++j){
                        for(int k = 0; k < rightTrees.size(); ++k){
                            // create root node
                            TreeNode *root = new TreeNode(i);
                            root->left = leftTrees[j];
                            root->right = rightTrees[k];
                            res.push_back(root);
                        }
                    }
                }
            }
        }
        return res;
    }
    // generate trees
    vector<TreeNode *> generateTrees(int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        return generateTrees(1, n);
    }
};