leetcode Unique Binary Search Trees II_taoqick binary-优快云博客

本文链接：https://blog.youkuaiyun.com/taoqick/article/details/12836867

本文介绍了一种算法，用于生成所有可能的独特二叉搜索树（BST），这些树可以存储从1到n的值。通过递归地构建左子树和右子树，并组合它们来创建完整的树，该算法有效地解决了问题。

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

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

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

The main problem is how to save the results from both left children and right children. But the answer is, there is no better solution than a vector for left children and a vector for right children. The following is the code:

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
 public:
  vector<TreeNode*> generate(vector<int>& node, int start, int end) {
    vector<TreeNode*> res, lchild, rchild;
    TreeNode *parent, *lc, *rc;
    if (start > end) {
      res.push_back(NULL);
      return res;
    }
    if (start == end) {
      parent = new TreeNode(node[start]);
      res.push_back(parent);
      return res;
    }
    else {
      for (int i = start; i <= end; i++) {
        lchild = generate(node, start, i-1);
        rchild = generate(node, i+1, end);
        for (int m = 0; m < lchild.size(); m++) 
          for (int n = 0; n < rchild.size(); n++) {
            parent = new TreeNode(node[i]);
            parent->left = lchild[m];
            parent->right = rchild[n];
            res.push_back(parent);
          }
      }
      return res;
    }
  }
  vector<TreeNode *> generateTrees(int n) {
    // Note: The Solution object is instantiated only once and is reused by each test case.
    vector<TreeNode*> res;
    vector<int> node;
    for (int i=1; i <= n; ++i) 
      node.push_back(i);
    res = generate(node, 0, n-1);
    return res;  
  }
};

After typing the code, I found there is no need to give the parameter node.

Give a WA Code here, find the bug:

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
 public:
  vector<TreeNode*> generate(int start, int end) {
    vector<TreeNode*> res;
    TreeNode *root = NULL;
    if (start > end) {
      res.push_back(NULL);
      return res;
    }
    if (start == end) {
      root = new TreeNode(start);
      res.push_back(root);
      return res;
    } 
    for (int i = start; i <= end; ++i) {
      vector<TreeNode*> l = generate(start, i - 1);
      vector<TreeNode*> r = generate(i + 1, end);
      for (int j = 0; j < l.size(); ++j)
        for (int k = 0; k < r.size(); ++k) {
          root = new TreeNode(i);
          root->left = l[j];
          root->right = r[k];
          res.push_back(root);
        }      
    }
    return res;
  }
  vector<TreeNode*> generateTrees(int n) {
    return generate(1, n);
  }
};

Python version:

class Solution:
    def generate_sub_tree(self, start, end):
        res = []
        if (start+1 == end):
            return [TreeNode(start)]
        elif (start >= end):
            return [None]
        else:
            for i in range(start, end):
                left_subtrees = self.generate_sub_tree(start,i)
                right_subtrees = self.generate_sub_tree(i+1, end)
                for l in left_subtrees:
                    for r in right_subtrees:
                        cur_root = TreeNode(i)
                        cur_root.left = l
                        cur_root.right = r
                        res.append(cur_root)
            return res

    def generateTrees(self, n):
        if n == 0:
            return []
        res = self.generate_sub_tree(1, n+1)
        return res