Leetcode_unique-binary-search-trees-ii

最新推荐文章于 2019-04-12 11:20:43 发布

fibo_nacci

最新推荐文章于 2019-04-12 11:20:43 发布

阅读量513

点赞数

分类专栏： Leetcode

本文链接：https://blog.csdn.net/flyupliu/article/details/24052921

版权

Leetcode 专栏收录该内容

155 篇文章 0 订阅

订阅专栏

地址：http://oj.leetcode.com/problems/unique-binary-search-trees-ii/

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

思路：个数是C(2N, N) / (N+1)，和矩阵相乘交换的形式个数是一样的，有个更专业的说法是catalan数，维基 http://zh.wikipedia.org/zh/%E5%8D%A1%E5%A1%94%E5%85%B0%E6%95%B0

用递归的思路，在网上看了一个非常优雅的递归，自叹不如，优雅之处是在left>right时候push NULL 到vector，一般的解法是当检测到left>right时候不再调用递归，代码里直接赋NULL，这样就比较麻烦。

参考代码：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> subtree(int left, int right)
    {
        vector<TreeNode*>ans; 
        if(left > right)
        {
            ans.push_back(NULL);
            return ans;
        }
        
        for(int i = left; i<=right; ++i)
        {
            vector<TreeNode*>left_tree = subtree(left, i-1);
            vector<TreeNode*>right_tree = subtree(i+1, right);
            for(int j = 0; j<left_tree.size(); ++j)
            {
                for(int k = 0; k<right_tree.size(); ++k)
                {
                    TreeNode *root = new TreeNode(i);
                    root->left = left_tree[j];
                    root->right = right_tree[k];
                    ans.push_back(root);
                }
            }
        }
        return ans;
    }
    vector<TreeNode *> generateTrees(int n) {
        return subtree(1, n);
    }
};