最优二叉查找树

二叉查找树（BST，Binary Search Tree），又名二叉搜索树或二叉检索树，是一颗满足如下条件的树：

1、每个节点包含一个键值

2、每个节点有最多两个孩子

3、对于任意两个节点x和y，它们满足下述搜索性质:

a、如果y在x的左子树里，则key[y] <= key[x]

b、如果y在x的右子树里，则key[y] >= key[x]

最优二叉查找树（Optimal BST，Optimal Binary Search Tree）

最优二叉查找树是使查找各节点平均代价最低的二叉查找树。具体来说就是：给定键值序列K = ，k1 < k2 <.. < kn，其中键值ki,被查找的概率为pi，要求以这些键值构建一颗二叉查找树T，使得查找的期望代价最低（查找代价为检查的节点数）。

下面是对于查找期望代价的解释：

对于键值ki, 如果其在构造的二叉查找树里的深度（离开树根的分支数）为depthT(ki)，则搜索该键值的代价= depthT(ki) +1（需要加上深度为0的树根节点）。由于每个键值被查找的概率分别为pi，i=1,2,3…,n。所以查找期望代价为：

E[T的查找代价] = ∑i=1~n(depthT(ki) +1)*pi

时间复杂度

1、穷举

穷举构造最优二叉查找树，其实就是这样的一个问题：

给一个拥有n个数的已排序的节点，可以将其构造成多少种不同的BST（用来找到一个最优的二叉查找树）？

设可以构造成T(n)个，那么枚举每一个元素作为根节点的情况，当第一个元素作为根节点时，其余n-1个构成右子树，无左子树，是n-1情况时的子问题，共T(n-1)种；当第二个元素作为根节点时，左子树有1个元素，右子树有n-2个元素，根据乘法原理共有T(1)T(n-2)种情况……依此类推得到：T(n)= (0)T(n-1)+T(1)T(n-2)+T(2)T(n-3)+ ......+T(n-2)T(1)+T(n-1)T(0)；此外，有T(0)=T(1)=1。

下面来求解T(n)：

定义函数f(x) = T(0) + T(1)*x + T(2)*x2 + ......

那么有：

f(x)2 = (T(0)2) + (T(0)T(1) + T(1)T(0)) · x + (T(0)T(2) + T(1)T(1) + T(2)T(0)) · x2 + ......

= T(1) + T(2) · x + T(3) · x2 + ......

= (f(x) - T(0)) / x

= (f(x) - 1) / x

这样解方程得到f(x) = [1 - (1 - 4x)1/2] / 2x

右边进行泰勒展开，再与定义式比较最终得到：T(n) = (2n)! / (n!(n+1)!)

然后根据Stirling公式：n! ～(2πn)1/2*(n/e)n

于是有(2n)! / n!(n+1)! ～(4n1/2*2n2n) / (2n1/2*nn*(2(n+1))1/2*(n+1)n)

～4n*(n+1)-3/2*(n/(n+1))n ～4n*n-3/2

因此最后得到穷举方法构造最优二叉查找树的时间复杂度：T(n) = O(4n*n-3/2)

2、递归

实际上左右子树是互不影响的，不需要穷举所有左右子树的组合，所以不需要用乘法原理，加法原理就可以了，这样式子变为：

T(n) = T(0) + T(n-1) + T(1) + T(n-2) + T(2) + T(n-3) + ...... + T(n-2) + T(1) + T(n-1) + T(0) = 2(T(0) + T(1) + T(2) + ...... + T(n-1))

= 3T(n-1)

所以得到T(n) = O(3n)，还是指数级的一个算法

3、动态规划

上面得到指数级算法的原因在于，计算了很多重复的子树情况，一些子树的查找代价被计算了很多遍；而一棵树如果是最优二叉搜索树，那么要么它是空树，要么它的左、右子树也是最优二叉搜索树，因此只需要将子树的查找代价记录下来，采用记忆化搜索或者是自底向上的动态规划的方法，虽然需要消耗一定的空间，但可以把时间复杂度从指数级降到多项式级，这些空间消耗也是可以接受的。

以下是采用自底向上的解法：

输入：键值序列K = ，概率序列P =

输出：两个二维数组，Price[i][j]表示ki到kj构成的最优子树的查找代价，Root[i][j]表示表示ki到kj构成的最优子树的根节点位置（用于重构最优二叉查找树）

算法1：

For 子树大小size = 1 to n

For 子树的起点start = 1 to (n - size + 1) //这样子树的终点即为end = start + size -

1，长度为size

For 该子树的所有节点作为根节点root = start to end

对于每个root，根据之前计算过的Price数组得到左右最优子树的代价，可直接得到该子树的代价price为：左右子树的最优子树代价之和+ 所有节点的访问概率之和（因为所有节点都下降了一层）在内层循环中找到代价最小的price和root分别记录在Price[start][end]和Root[start][end]中。

下面分析这个算法的时间复杂度：

由于除了计算出我们最后需要得到的Price和Root二维数组，还产生了部分冗余的子树，因此不能简单的将算法归结为O(n2)的算法。

对于子树大小为1时，我们考察了n个子树；

对于子树大小为2时，一共产生了(n - 1)个最优子树，但是在我们的每次考察中，都将子树的所有节点作为根节点考虑过一次，因此每得到1个大小为2的子树，我们需要考察2个不同的子树来找到一个代价最小的，因此最后我们实际上考察了2(n - 1)个子树；

对于子树大小为3时，类似的，我们考察了3(n - 2)个子树……

对于子树大小为n时，我们考察了n个子树。

最后，我们一共考察了T(n) = n + 2(n - 1) + 3(n - 2) + ...... + n个子树。

求解这个公式依然可以借用之前的方法，定义函数f(x) = 1 + 2x + 3x2 + ...... = (1 - x)-2 这样一来f(x)2 = T(1) + T(2)*x + T(3)*x2 + ......

再借用泰勒展开得到T(n) = (n + 2)(n + 1)n/6 = O(n3),或者把所有项视为n2，则有T(n) ≤n2 + n2 + n2 + n2 + ...... = (n+1)n2 ≤2n3,或者把中间n/2项都视为n/4*3n/4的话，则有T(n)≥n/2*n/4*3n/4 = (3/32)n3，根据时间复杂度的定义有T(n) = O(n3)