《算法导论》ʚ读书笔记&浅析ɞ 第十五章 - 最优二叉搜索树(包含js版代码实现)

背景简介

关于二叉搜索树

关于最优二叉搜索树，算法导论给了一个生动的例子。以下是描述截图：

从上述的截图中可以知道搜索一个单词是有搜索成本的，我们将它定义为

dx 代表伪节点(正常节点都未命中时的虚拟节点)

pi 第i个节点命中的概率

qi 第i个伪节点命中的概率

举个例子：

第2个节点的搜索代价 = (K2深度+1)*P2 + (D2深度+1)*Q2 = (0+1)**0.10 + (3+1)**0.02

我们需要找出期望搜索代价最小的二叉搜索树

算法思想

我们假设这棵树(T)是最优二叉搜索树,那么它的子树必定也是最优二叉搜索树。可以用反证法来理解这个问题，假如它的子树不是最优二叉搜索树(假定为a)，我们将其替换成最优二叉搜索子树(假定为b)。那么b的搜索代价一定是小于a的，那么原来树T的其他搜索代价假设为t

t+a > t+b 与 假设这棵树(T)是最优二叉搜索树 是相违背的

所以问题就变成了(正向思维):求T的最优二叉搜索树 = T的最优二叉左子树 + T的最优二叉右子树 + 根节点,递归式就有了。

假定求解ki~kj节点的最优二叉搜索树,其根节点为kr

假定期望搜索代价为e[i,j]

假定ki~kj的期望搜索代价之和为w[i,j]

这里分为两种情况

1. j = i - 1 表示子树没有节点 只有伪节点 所以 e[i,i-1] = qi-1
2. j≥ i-1 的情况比较复杂

当原来的树结构发生变化 在他们上面多了一个r节点的时候 看下图的变化

子树所有节点的深度都+1了，会增加搜索代价
所以可以得到下图所示的公式

整理一下之后可以得到

最终我们可以得到

算法过程

根据上述的过程 我们需要 e ，w，root 三张表避免重复计算

    let e = newTable(n + 1, n + 1)
    let w = newTable(n + 1, n + 1)
    let root = newTable(n, n)

处理j=i-1的情况

    for (let i = 1; i <= n + 1; i++) {
        e[i][i - 1] = q[i - 1]
        w[i][i - 1] = q[i - 1]
    }

需要三层循环(与矩阵链乘几乎一模一样)

1.遍历1-n各个长度的情况

 for (let l = 1; l <= n; l++)

2.可以理解为同样的l长度 滑动窗口 例如 12，23， 34， 45，

for (let i = 1; i <= n - l + 1; i++)

3.遍历每个r的情况取最小值

代码实现

//生成二维数组
function newTable(m, n) {
    let arr = [];
    for (let i = 0; i <= m; i++) {
        let arrInside = [];
        for (let j = 0; j <= n; j++) {
            arrInside.push(0);
        }
        arr.push(arrInside);
    }
    return arr;
}

//生成对照表
function createTable(p, q, n) {
    let e = newTable(n + 1, n + 1)
    let w = newTable(n + 1, n + 1)
    let root = newTable(n, n)
    for (let i = 1; i <= n + 1; i++) {
        e[i][i - 1] = q[i - 1]
        w[i][i - 1] = q[i - 1]
    }
    for (let l = 1; l <= n; l++) {
        for (let i = 1; i <= n - l + 1; i++) {
            j = i + l - 1
            e[i][j] = Infinity
            w[i][j] = w[i][j - 1] + p[j] + q[j]
            for (let r = i; r <= j; r++) {
                let t = e[i][r - 1] + e[r + 1][j] + w[i][j]
                if (t < e[i][j]) {
                    e[i][j] = t
                    root[i][j] = r
                }
            }
        }
    }
    return { e, root }
}

function OptimalBst(p, q, n) {
    const { root } = createTable(p, q, n)
    let tree = []
    const find = (root, i, j) => {
        if (i <= j) {
            let r = root[i][j]
            tree.push('k' + r)
            find(root, i, r - 1)
            find(root, r + 1, j)
        }
    }
    find(root, 1, 5)
    return tree
}

module.exports = OptimalBst