Unique Binary Search Trees II

------QUESTION------

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

------SOLUTION------

class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        vector<TreeNode*> result;
        if(n==0)
        {
            result.push_back(NULL);
            return result;
        }
        recursion(1,n, result);
        return result;
    }
    
    void recursion(int start, int end, vector<TreeNode*> &root)
    {
        if(start == end) 
        {
            root.push_back(new TreeNode(start));
            return;
        }
        
        for(int i = start; i<=end; i++) 
        {   
            vector<TreeNode*> leftTree;
            vector<TreeNode*> rightTree;
            if(i > start) 
            {
                recursion(start, i-1, leftTree);
            }
            if(i < end)
            {
                recursion(i+1, end, rightTree);
            }
            if(leftTree.empty())
            {
                for(int j = 0; j< rightTree.size(); j++)
                {
                    TreeNode* newRoot = new TreeNode(i); 
                    newRoot->right = rightTree[j];
                    root.push_back(newRoot);
                 }
            }
            else if(rightTree.empty())
            {
                 for(int j = 0; j< leftTree.size(); j++)
                 {
                     TreeNode* newRoot = new TreeNode(i); 
                     newRoot->left = leftTree[j];
                     root.push_back(newRoot);
                 }
            }
            else{
                 for(int j = 0; j< leftTree.size(); j++)
                 {
                     for(int k = 0; k< rightTree.size(); k++)
                     {
                         TreeNode* newRoot = new TreeNode(i);
                         newRoot->left = leftTree[j];
                         newRoot->right = rightTree[k];
                         root.push_back(newRoot);
                     }
                 }
            }
        }  
    }
};