[leetcode]Unique Binary Search Trees II

#include<iostream>
#include<vector>
using namespace std;
struct TreeNode
{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val):val(val),left(NULL),right(NULL){};
};
class Solution 
{
public:
    vector<TreeNode *> generateTrees(int n)
    {
        if (n == 0) return generate(1, 0);
            return generate(1, n);
    }
    void display(TreeNode* root)
    {
        if(!root)
            return;
        cout<<root->val<<' ';
        display(root->left);
        display(root->right);
    }
private:
    vector<TreeNode *> generate(int start, int end)
    {
        vector<TreeNode*> subTree;
        if (start > end)
        {
            subTree.push_back(nullptr);
            return subTree;
        }
        for (int k = start; k <= end; k++)
        {
            vector<TreeNode*> leftSubs = generate(start, k - 1);
            vector<TreeNode*> rightSubs = generate(k + 1, end);
            for (auto i : leftSubs)
            {
                for (auto j : rightSubs)
                {
                    TreeNode *node = new TreeNode(k);
                    node->left = i;
                    node->right = j;
                    subTree.push_back(node);
                }
            }
        }
        return subTree;
    }
};



void main()
{
    Solution solution;
    vector<TreeNode*>result;
    result=solution.generateTrees(3);
    for(auto i:result)
    {
        solution.display(i);
        cout<<endl;
    }
}