【LeetCode】Unique Binary Search Trees && II

最新推荐文章于 2020-12-09 16:51:01 发布

原创最新推荐文章于 2020-12-09 16:51:01 发布 · 490 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#二叉树 #leetcode

LeetCode 同时被 2 个专栏收录

86 篇文章

订阅专栏

树

9 篇文章

订阅专栏

本文介绍如何计算给定数值范围内不同结构的二叉搜索树的数量，并生成所有可能的二叉搜索树结构。通过动态规划方法解决Unique Binary Search Trees 和 Unique Binary Search Trees II两个经典问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考

http://www.cnblogs.com/remlostime/archive/2012/11/19/2777841.html

http://blog.youkuaiyun.com/maqingli87/article/details/8010563

题目描述

Unique Binary Search Trees

Given n, how many structurally unique BST's (binary search trees) that store values 1...n?

For example,
Given n = 3, there are a total of 5 unique BST's.

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

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

题目分析

这是一个动态规划的题目，用递归或循环法都可以，需要注意的，前面计算下来的结果，要记录下来，不要重复计算就可以了。

总结

代码示例

/*
编译环境CFree 5.0
博客地址：http://blog.youkuaiyun.com/Snowwolf_Yang
*/
#include 
   
    
#include 
    
     
#include 
     
       
using namespace std;

#if 0 
class Solution {
public:
    int numTrees(int n) {
    	vec.resize(n+1);
    	vec[0] = 1;
    	return numTreesCore(n);
    }
    int numTreesCore(int n)
    {
    	if(vec[n]>0)	return vec[n];        
       	int num = 0;
       	for(int i=0;i
      
        vec;
};
#elif 1
class Solution {
public:
    int numTrees(int n) {
    	vec.resize(n+1);
    	if(n >0)vec[0] = 1;
		if(n >0)vec[1] = 1;
		if(n >1)vec[2] = 2;
    	if(n >2)
	       	for(int i=3;i<=n;i++)
	       	{
	       		vec[i] = 0;				//这里需要初始化 
	       		for(int j = 0;j
       
         vec;
};

#endif
void check(int x,int expected)
{
	if(x==expected)
		printf("---------------------passed\n");
	else
		printf("---------------------failed\n");	
}
int main()
{
	printf("main begin\n");
	Solution so;
	//check(so.numTrees(1),1);
	//check(so.numTrees(2),2);
	check(so.numTrees(3),5);
	check(so.numTrees(4),14);
//	check(so.numTrees(5),0);
	return 0;
}
/*

class Solution {
public:
    int numTrees(int n) {
    	vec.resize(n+1);
    	return numTreesCore(n);
    }
    int numTreesCore(int n)
    {
    	if(vec[n]>0)
		{  	
			//printf("*vec[%d] = %d\n",n,1);
			return vec[n];
		}
        if(n == 0)	
		{
			vec[n] = 1;
			//printf("0vec[%d] = %d\n",n,1);
			return 1;
		}        
       	int num = 0;
       	for(int i=0;i
        
          vec; }; */

/**
 * 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 *> generateTrees(int n) {
        return generateTreesHelper(1, n);
    }
    vector<TreeNode *> generateTreesHelper(int begin, int end) {
        vector<TreeNode *> ret;
        if (end < begin) {
            ret.push_back(NULL);
            return ret;
        }
        for (int i = begin; i<= end; i++) {
            vector<TreeNode *> left = generateTreesHelper(begin, i - 1);
            vector<TreeNode *> right = generateTreesHelper(i + 1, end);
            for (int m = 0; m < left.size(); m++) {
                for (int n = 0; n < right.size(); n++) {
                    TreeNode * root = new TreeNode(i);
                    root->left = left[m];
                    root->right = right[n];
                    ret.push_back(root);
                }
            }
        }
        return ret;
    }
};