Leetcode 95. Unique Binary Search Trees II

95. Unique Binary Search Trees II

• Total Accepted: 61324
• Total Submissions: 207585
• Difficulty: Medium

Given an integer 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

思路：

方法一：DP。首先注意n=0的情况；当n>=1时，假设n个结点的二叉查找树的根结点为root(n)。对于val==n的d单个结点f(n)，root(n)可以通过以下2种方式形成：

1.  f(n)->left=root(n)

2.  curTree.size()=n-1

while(f(n)) 

　　f(n)->left=root(subRightTree.size())

　　root(curTree.size())->right=f(n)

　　记录root(n)，恢复root(n)

　　当前子树指向其右子树

不断遍历右子树，直到右子树为空

方法二：分而治之。

这里亲测测试数据中有n=0的测试，并且n=0时，要返回[]，而不是[[]]

代码：

方法一：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* clone(TreeNode* root){
        if(!root) return NULL;
        TreeNode* res=new TreeNode(root->val);
        res->left=clone(root->left);
        res->right=clone(root->right);
        return res;
    }
    vector<TreeNode*> generateTrees(int n) {
        vector<TreeNode*> res;
        if(!n) return res;
        TreeNode *cur=new TreeNode(1),*head,*pre,*tail;
        res.push_back(cur);
        for(int i=2;i<=n;i++){
            int size=res.size();
            for(int j=0;j<size;j++){
                cur=new TreeNode(i);
                head=res[0];
                res.erase(res.begin());
                pre=head;
                while(pre!=NULL){
                    tail=pre->right;
                    pre->right=cur;
                    cur->left=tail;
                    res.push_back(clone(head));
                    cur->left=NULL;
                    pre->right=tail;
                    pre=tail;
                }
                cur->left=head;
                res.push_back(cur);
            }
        }
        return res;
    }
};

方法二：

class Solution {
public:
    vector<TreeNode*> generateTree(int begin,int end){
        vector<TreeNode*> left,right,res;
        if(begin>end){
            res.push_back(NULL);
            return res;
        }
        for(int i=begin;i<=end;i++){
            left=generateTree(begin,i-1);
            right=generateTree(i+1,end);
            for(auto lnode:left){
                for(auto rnode:right){
                    TreeNode* root=new TreeNode(i);
                    root->left=lnode;
                    root->right=rnode;
                    res.push_back(root);
                }
            }
        }
        return res;
    }
    vector<TreeNode*> generateTrees(int n) {
        if(!n) return vector<TreeNode*>();
        return generateTree(1,n);
    }
};