96.不同的二叉搜索树

题目

给定一个整数 n,求以 1 … n 为节点组成的二叉搜索树有多少种?
示例:
输入: 3
输出: 5
解释:
给定 n = 3, 一共有 5 种不同结构的二叉搜索树:
在这里插入图片描述
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/unique-binary-search-trees

代码及分析

二叉搜索树,又被称为是二叉查找树、二叉排序树,这种树其左子树所有节点的值均小于根节点的值,其右子树所有节点的值均大于根节点的值,并且其左、右子树均为二叉搜索树。
空树也是二叉搜索树。
方法一:动态规划法

这道题可以用动态规划的思想去解决。由于给定的节点值为1~n,是一组从小到大顺序排列的数据,其中,任意一个值均可以作为根节点出现,记为 i,i的取值范围为1 ~ n。当以 i 为根节点时,为了满足搜索树的性质,其左子树必定有1 ~ i-1 构成,右子树必定由 i+1 ~ n 构成。
建立动态转移数组dp, dp[n] 表示由 1 ~ n构成的二叉搜索树的个数;记 f( i ) 为由 i 作为根节点时,其对应的二叉搜索树的个数,则有f(i) = dp[i-1] * dp [n-i]。
显然有:
d p [ n ] = ∑ i = 1 n f ( i ) = ∑ i = 1 n ( d p [ i − 1 ] ∗ d p [ n − i ] ) dp[n] = \sum\limits_{i=1}^nf(i) = \sum\limits_{i=1}^n(dp[i-1] * dp [n-i]) dp[n]=i=1nf(i)=i=1n(dp[i1]dp[ni])

 int numTrees(int n) {
        if(n < 0)
            return 0;
        vector<int> dp(n+1,0);
        dp[0] = 1;
        dp[1] = 1;
        for(int i = 2; i <= n; i++)
        {
            for(int j = 1; j <= i; j++)  // 以j为根
            {
                dp[i] += dp[j-1]*dp[i-j];
            } 
        }
        return dp[n];
    }
复杂度:

时间复杂度: O(n^2) ( ∑ i = 2 n ( ( n + 2 ) ( n − 1 ) 2 ) \sum\limits_{i=2}^n(\frac{(n+2)(n-1)}{2}) i=2n2n+2(n1) )。
空间复杂度: O(n) 。

方法二:卡塔兰数n阶递推关系求解

上述问题其实相当于是卡塔兰数。
卡塔兰数是组合数学中一个常在各种计数问题中出现的数列。
令h(0)=1,h(1)=1,卡塔兰数满足递归式:
h(n)= h(0)*h(n-1) + h(1)*h(n-2) + … + h(n-1)h(0) (其中n>=2),这是n阶递推关系,与上面我们推导出的动态转移方程一致。
卡塔兰数的一般公式为 h ( n ) =   C 2 n n ( n + 1 ) h(n)=\ \frac{C_{2n}^{n}}{(n+1)} h(n)= (n+1)C2nn

int numTrees(int n) {
        if(n < 0)
            return 0;
        long res = 1;
        for(int i = n + 1; i <= 2 * n; i++)
        {
            res = res * i / (i - n);
        }
        return res / (n + 1);
    }
复杂度:

时间复杂度: O(n) ;
空间复杂度: O(1) 。

方法三:卡塔兰数1阶递推关系求解

卡塔兰数的n阶递推关系,还可以化简为1阶递推关系:
h ( n ) = ( 4 n + 2 ) ( n + 2 ) h ( n − 1 ) ( n &gt; 1 ) h ( 0 ) = 1 h(n)= \frac{(4n+2)}{(n+2)}h(n-1) \quad (n&gt;1) \quad h(0)=1 h(n)=(n+2)(4n+2)h(n1)(n>1)h(0)=1

int numTrees(int n) {
        if(n < 0)
            return 0;
        long res = 1;
        for(int i = 1; i < n; i++)
        {
            res = res * 2 * (2 * i + 1) / (i+2);
        }
        return res;
    }
复杂度:

时间复杂度: O(n) ;
空间复杂度: O(1) 。

好的,我来解答你的问题。 对于这个问题,我们可以按照以下步骤来解决: 步骤1:构建二叉搜索树 我们可以使用给定的数据元素来构建一棵二叉搜索树,具体构建方法可以参考二叉搜索树的构建方法。 步骤2:遍历二叉搜索树 同样按照二叉搜索树的遍历方法,对构建好的二叉搜索树进行遍历,可选择前序遍历、中序遍历或后序遍历。 步骤3:转换为双链表 对于二叉搜索树转换为双链表,我们可以使用中序遍历,按照从小到大的顺序将树中的节点连接起来。具体实现方法如下: 1. 定义一个全局变量pre,用来记录上一个节点 2. 对于每个节点,先将其左子树转换为双链表,然后将该节点与pre连接起来,更新pre为当前节点,最后将右子树转换为双链表 3. 最后返回双链表的头节点(即最左侧的节点) 步骤4:打印双链表 按照双链表的结构,我们可以从头节点开始遍历,依次输出每个节点的值。 步骤5:按正反序输出双链表中的所有元素 对于双链表的正反序输出,我们可以定义两个指针,一个指向头节点,一个指向尾节点,然后分别从头尾开始遍历输出即可。 下面是示例代码,你可以参考一下: ```python # 定义二叉树节点 class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right # 构建二叉搜索树 def buildBST(nums): if not nums: return None mid = len(nums) // 2 root = TreeNode(nums[mid]) root.left = buildBST(nums[:mid]) root.right = buildBST(nums[mid+1:]) return root # 中序遍历将二叉搜索树转换为双链表 def convertBSTtoDLL(root): global pre pre = None def inorder(root): nonlocal pre if not root: return None inorder(root.left) if pre: pre.right = root root.left = pre pre = root inorder(root.right) inorder(root) while root.left: root = root.left return root # 打印二叉树 def printTree(root): if not root: return None print(root.val) printTree(root.left) printTree(root.right) # 打印双链表 def printDLL(head): while head: print(head.val) head = head.right # 按正序输出双链表 def printDLLForward(head): while head: print(head.val) head = head.right # 按反序输出双链表 def printDLLBackward(head): while head.right: head = head.right while head: print(head.val) head = head.left # 测试代码 nums = [1, 2, 3, 4, 5, 6, 7] root = buildBST(nums) print("打印二叉树:") printTree(root) head = convertBSTtoDLL(root) print("打印双链表:") printDLL(head) print("按正序输出双链表:") printDLLForward(head) print("按反序输出双链表:") printDLLBackward(head) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值