[LeetCode] 95. Unique Binary Search Trees II

Unique Binary Search Trees II

Given an integer n, generate all structurally unique BST’s (binary search trees) that store values 1 … n.
Example:

Input: 3
Output:
[
[1,null,3,2],
[3,2,null,1],
[3,1,null,null,2],
[2,1,3],
[1,null,2,null,3]
]
Explanation:
The above output corresponds to the 5 unique BST’s shown below:
1
\
3
/
2 等等

解析

递归构建二叉树，如果以 i 为根节点，那么其左子树由[1, i - 1]构成，右子树由[i + 1, n] 构成。要构建包含1到n的二叉搜索树，只需遍历1到n中的数作为根节点，以i为界将数列分为左右两部分，小于i的数作为左子树，大于i的数作为右子树，使用两重循环将左右子树所有可能的组合链接到以i为根节点的节点上。
例子：
举一个简单的数据验证下，以[1, 2, 3]为例，调用堆栈图如下所示：
helper(1,3)
[leftTree]: helper(1, 0) ==> return NULL
—loop i = 2—
[rightTree]: helper(2, 3)
[leftTree]: helper(2,1) ==> return NULL
[rightTree]: helper(3,3) ==> return node(3)
[for loop]: ==> return (2->3)
—loop i = 3—
[leftTree]: helper(2,2) ==> return node(2)
[rightTree]: helper(4,3) ==> return NULL
[for loop]: ==> return (3->2)

代码

class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        if(n == 0)
            return {};
        return helper(1,n);
    }

    vector<TreeNode* > helper(int start, int end){
        vector<TreeNode *> result;
        if(start > end){
            result.push_back(NULL);
            return result;
        }
        for(int i=start; i <= end;i++){
            vector<TreeNode* > lefttree = helper(start, i-1);
            vector<TreeNode* > righttree = helper(i+1, end);
            for(int j=0; j < lefttree.size(); j++){
                for(int k=0; k < righttree.size(); k++){
                    TreeNode* root = new TreeNode(i);
                    root->left = lefttree[j];
                    root->right = righttree[k];
                    result.push_back(root);
                }
            }
        }
        return result;
    }
};

上述代码需要大量拷贝，使用指针存储变量，代码如下：

class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        if(n == 0)
            return {};
        return *helper(1,n);
    }

    vector<TreeNode* > *helper(int start, int end){
        vector<TreeNode *> *result = new vector<TreeNode*>();
        if(start > end){
            result->push_back(NULL);
            return result;
        }
        for(int i=start; i <= end;i++){
            vector<TreeNode* > *lefttree = helper(start, i-1);
            vector<TreeNode* > *righttree = helper(i+1, end);
            for(int j=0; j < lefttree->size(); j++){
                for(int k=0; k < righttree->size(); k++){
                    TreeNode* root = new TreeNode(i);
                    root->left = (*lefttree)[j];
                    root->right = (*righttree)[k];
                    result->push_back(root);
                }
            }
        }
        return result;
    }
};

参考

https://www.kancloud.cn/kancloud/data-structure-and-algorithm-notes/73055
http://www.cnblogs.com/grandyang/p/4301096.html