算法设计与分析--最优二叉搜索树（Python）

最优二叉搜索树：

给定一个n个不同关键字的已排序的序列K=<k1,k2,…,kn>（因此k1<k2<…<kn）我们希望用这些关键字构造一棵二叉树。对每个关键字ki,都有一个概率pi表示其搜索频率。

有些要搜索的值可能不在K中，因此，我们还有n+1个“伪关键字”d0,d1,d2,…,dn表示不在K中的值。d0表示所有小于k1的值，dn表示所有大于kn的值，对i=1,2,…,n-1伪关键字di表示所有在ki和k(i+1)之间的值。

对每个伪关键字di也都有一个概率qi表示对应的搜索频率。
假定一次搜索的代价等于访问的结点数，即此次搜索找到的结点在T中的深度再加1.那么在T中进行一次搜索的期望代价为：

对于一个给定的概率集合，我们希望构造一棵期望搜索代价最小的二叉搜索树，我们称之为最优二叉搜索树。

用动态规划方法求解此问题：

步骤1：最优二叉搜索树的结构：

考虑一棵二叉搜索树的任意子树，它必须包含连续关键字ki，…，kj（1<=i<=j<=n），而且其叶结点必然是伪关键字d(i-1),…,dj。

最优子结构：

如果一棵最优二叉搜索树T中有一棵包含关键字ki，…，kj（1<=i<=j<=n）的子树T‘，那么T’必然是包含关键字ki，…，kj和伪关键字d(i-1),…,dj的子问题的最优解。
步骤2：一个递归算法
root[i, j]保存根结点kr的下标r。
步骤3：计算最优二叉搜索树的期望搜索代价

def OptimalBinarySearchTree(q,p,n,e,root,w):
    #n表示内结点个数
    #w[i][j]是内结点bi到bj构成的子树的存取概率之和，包括两边的叶子结点
    #e[i][j]表示搜索代价
    for i in range(n+1):
        w[i+1][i]=q[i]
        e[i+1][i]=0
    for r in range(n):#r:结点个数-1
        for i in range(1,n-r+1):
            j=i+r
            w[i][j]=round(w[i][j-1]+q[j]+p[j],3)
            e[i][j]=round(e[i+1][j]+w[i][j],3)
            root[i][j]=i
            
            #k表示用不同的元素作为根节点
            for k in range(i+1,j+1):
                t=round(e[i][k-1]+e[k+1][j]+w[i][j],3)
                if t<e[i][j]:
                    e[i][j]=t
                    root[i][j]=k
    print("e")
    for i in range(1,n+2):
        print(e[i][1:])
    print('root')
    for i in range(1,n+2):
        print(root[i][1:])
    print('w')
    for i in range(1,n+2):
        print(w[i])

#叶子结点的存取概率
q=[0.05,0.10,0.05,0.05,0.05,0.10]
#内结点的存取概率
p=[0,0.15,0.10,0.05,0.10,0.20]
n=len(p)-1
e,root,w=[],[],[]
for i in range(n+2):
    e.append([0]*(n+1))
    root.append([0]*(n+1))
    w.append([0]*(n+1))
OptimalBinarySearchTree(q,p,n,e,root,w)

运行结果如图