查找所有唯一二叉搜索树的算法的时间复杂度是多少？

Question

唯一的二叉搜索树
给定 n，生成所有结构唯一的 存储值 1...n 的 BST（二叉搜索树）。

例如，给定n = 3，
你的程序应该返回所有 5 个唯一的 BST 如下所示。

    1         3         3         2         1 
     \       /         /         / \         \ 
      3     2         1         1   3         2 
     /     /           \                       \ 
    2     1             2                       3

---

个人认为，
时间复杂度= O(n^n)，n是输入。
但时间复杂度更紧是什么？

---

C++

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
#include <vector>
using namespace std;

class Solution {
public:
    vector<TreeNode *> generateTrees(int n) {
        vector<TreeNode *> list;

        // Input validation.
        if (n <= 0) {
            list.push_back(NULL);
            return list;
        }

        int left = 1;
        int right = n;
        generateTrees(left, right, list);

        return list;
    }

    void generateTrees(int left, int right, vector<TreeNode *> &list) {
        // Base case.
        if (left > right) {
            list.push_back(NULL);
            return;
        }

        for (int i = left; i <= right; i ++) {
            vector<TreeNode *> left_trees;
            generateTrees(left, i - 1, left_trees);

            vector<TreeNode *> right_trees;
            generateTrees(i + 1, right, right_trees);

            for (vector<TreeNode *>::iterator left_it = left_trees.begin();
                 left_it != left_trees.end(); left_it ++) {

                TreeNode *leftTree = *left_it;

                for (vector<TreeNode *>::iterator right_it = right_trees.begin();
                     right_it != right_trees.end(); right_it ++) {

                    TreeNode *rightTree = *right_it;

                    TreeNode *root = new TreeNode(i);
                    root->left = leftTree;
                    root->right = rightTree;

                    list.push_back(root);
                }         
            } 
        }
    }
};

Answer 1

给定n个节点，二叉搜索树的总数是加泰罗尼亚数，请参考这个链接：http://en.wikipedia.org/wiki/Catalan_number。所以，时间复杂度也是O(Catalan(n))。