Unique Binary Search Trees II（leetocde）

Unique Binary Search Trees II（leetocde）

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

代码：

class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        vector<TreeNode*> NextSolution, frontSolution;
        if (!n) return frontSolution;
        frontSolution.push_back(new TreeNode(1));
        for (int i = 2; i <= n; ++i) {
            getNextRootTree(NextSolution, i, frontSolution);
            getNextNotRootTree(NextSolution, i, frontSolution);
            deleteTrees(frontSolution);
            frontSolution = NextSolution;
            NextSolution.clear();
        }
        return frontSolution;
    }
    void deleteTrees(vector<TreeNode*>& trees) {
        for (int i = 0; i < trees.size(); ++i) {
            deleteTree(trees[i]);
        }
        trees.clear();
    }
    void deleteTree(TreeNode* tree) {
        if (!tree) return;
        deleteTree(tree->left);
        deleteTree(tree->right);
        delete tree;
    }
    void getNextRootTree(vector<TreeNode*>& result, int val, vector<TreeNode*>& frontSolution) {
        TreeNode* n;
        for (int i = 0; i < frontSolution.size(); ++i) {
            n = new TreeNode(val);
            n->left = copyTree(frontSolution[i]);
            result.push_back(n);
        }
    }
    TreeNode* copyTree(TreeNode* h) {
        if (!h) return NULL;
        TreeNode* head = new TreeNode(h->val);
        head->right = copyTree(h->right);
        head->left = copyTree(h->left);
        return head;
    }
    void getNextNotRootTree(vector<TreeNode*>& result, int val, vector<TreeNode*>& frontSolution) {
        for (int i = 0; i < frontSolution.size(); ++i) {
            travelRightAndAddTree(result, frontSolution[i], frontSolution[i], val);
        }
    }
    void travelRightAndAddTree(vector<TreeNode*>& result, TreeNode* root, TreeNode* h, int val) {
        if (!h) return;
        result.push_back(copyTreeAndInsertNodeNotRoot(root, h, val));
        travelRightAndAddTree(result, root, h->right, val);
    }
    TreeNode* copyTreeAndInsertNodeNotRoot(TreeNode* h, TreeNode* f, int val) {
        if (!h) return NULL;
        TreeNode* copynode = new TreeNode(h->val);
        copynode->left = copyTreeAndInsertNodeNotRoot(h->left, f, val);
        if (h != f) {
            copynode->right = copyTreeAndInsertNodeNotRoot(h->right, f, val);
        } else {
            copynode->right = new TreeNode(val);
            copynode->right->left = copyTreeAndInsertNodeNotRoot(h->right, f, val);
        }
        return copynode;
    }
};