Get All Possible Binary Trees Given n

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void copyTree(TreeNode * & newTree, TreeNode *oldTree){
      if(oldTree==NULL) newTree=NULL;
      else {
        newTree = new TreeNode(oldTree->val);
        copyTree(newTree->left, oldTree->left);
        copyTree(newTree->right, oldTree->right);
      }
    }
    void GetNewTrees(TreeNode *node, TreeNode *curr, int n, vector<TreeNode *> &result){
       if(node==NULL || curr==NULL) return;
      
       TreeNode *newNode;
       TreeNode *newTree;
      
       if(curr==node){
   newNode = new TreeNode(n);
         newNode->left = node;
         //newTree = new TreeNode(0);
         //copyTree(newTree, newNode);
         result.push_back(newNode);
         newNode = new TreeNode(n);
         newNode->right = node;
         //newTree = new TreeNode(0);
         //copyTree(newTree, newNode);
         result.push_back(newNode);
       }
      
       if(curr->left==NULL){
   newNode = new TreeNode(n);
         curr->left = newNode;
         copyTree(newTree, node);
         result.push_back(newTree);
         curr->left = NULL; 
       }
       if(curr->right==NULL){
   newNode = new TreeNode(n);
         curr->right = newNode;
         copyTree(newTree, node);
         result.push_back(newTree);
         curr->right = NULL;
       }
      
       GetNewTrees(node, curr->left, n, result);
       GetNewTrees(node, curr->right, n, result);
    }
   
    void generate(int n, vector<TreeNode *> &result){
       TreeNode *root;
       if(n==1){
         root = new TreeNode(n);
         result.push_back(root);
         return;
       }
      
       generate(n-1, result);
       int size=result.size();
       TreeNode *subTree;
       for(int i=0;i<size;i++){
         subTree = result[i];
         GetNewTrees(subTree, subTree, n, result);
       }
      
       result.erase(result.begin(),result.begin()+size);
    }
   
    vector<TreeNode *> generateTrees(int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<TreeNode *> result;
        if(n<1) return result;
        generate(n, result);
    }
  };