最优二叉搜索树的java实现

问题来源：
我们在实现英语到汉语时，我们需要查询英语文本中的每一个单词所对用的汉语。我们此时可以构建一个二叉搜索树，将n个英语单词作为关键字，对应的汉语意思作为关联数据。也就时我们所理解key–value对。既然出现了二叉树，那么搜索二叉树的速度就成了我们需要关注的问题。主要问题就是，如果出现频率较低的英语单词放在根上，出现频率很高的英语单词出现在叶子节点，这样会使得我们每次的搜索都会很低效。

问题模型：
给定的n个不同关键字的已排序的序列K=k1,k2,…,kn，满足k1 < k2 < … < kn。同时，对于每个关键字对应的的搜索概率是Pi。
还有很多搜索的值不在K中，因此还由n+1个伪关键字，分别是d0，d1，d2，…，dn。d0 < k1, dn > kn。
注意：
1.每一个关键字ki是一个内部节点，而每一个伪关键字di是一个叶结点。
2.每次搜索要么成功搜索到关键字，要么失败搜索到伪关键字。
3.最优二叉搜索树不一定是高度最矮的。
4.概率最高的关键字也不一定在二叉搜索树的根节点。

递归算法实现：
求解包含关键字ki,…,kj的最优二叉搜索树，其中i>=1,j<=n且j>=i-1。这句话非常的重要：当j=i-1的时候，子树不包含实际关键字，只包含伪关键字。

定义e[i,j]是包含关键字ki,…,kj的最优二叉搜索树的期望代价。那么，我们最终的问题就是计算求出e[1,n]。

此刻，我们假设r结点就是从i到j的根节点。那么必有如下公式：

e[i,j] = e[i,r-1] + e[r+1,j] + w(i,j)

w(i,j)表示包含关键字ki到kj的子树，所有概率之和。

由于根节点r是未知的，所以我们得到最后的公式：

// j = i-1e[i,j] = q[i-1]// i <= je[i,j] = min{e[i,r-1] + e[r+1,j] + w(i,j)}//r从i取到j

作如下定义，为具体算法代码左准备：
e[n+2,n+1]:期望代价
root[n+2,n+1]:根节点
w[n+2,n+1]:保存临时结果

java代码如下：

/**     * @param p     *            :关键字搜索的概率     * @param q     *            :伪关键字搜索的概率     * @param n     *            :关键字的数量     * @return 返回最优二叉搜索树的代价和最优根结点     */    public static HashMap<Integer, double[][]> optional_bst(double p[], double q[], int n) {        // 存放回返的两个数组的集合        HashMap<Integer, double[][]> map = new HashMap<Integer, double[][]>();        // 用这个二维数组保存e[i][j]最小代价        double e[][] = new double[n + 2][n + 1];        // 用这个而为数组保存w[i][j]，以避免每次都重新计算        double w[][] = new double[n + 2][n + 1];        // root二维数组记录子树的根        double root[][] = new double[n + 2][n + 1];        // 初始化e和w数组        for (int i = 1; i < n + 2; i++) {            e[i][i - 1] = q[i - 1];            w[i][i - 1] = q[i - 1];        }        for (int l = 1; l < n + 1; l++) {            for (int i = 1; i < n - l + 2; i++) {                int j = i + l - 1;                e[i][j] = Integer.MAX_VALUE;                w[i][j] = w[i][j - 1] + p[j - 1] + q[j];                for (int r = i; r < j + 1; r++) {                    double t = e[i][r - 1] + e[r + 1][j] + w[i][j];                    if (t < e[i][j]) {                        e[i][j] = t;                        root[i][j] = (double) r;                    }                }            }        }        map.put(1, e);        map.put(2, root);        return map;    }

测试代码：

//规模为5的二叉树        double p[] = { 0.15, 0.10, 0.05, 0.10, 0.20 };        double q[] = { 0.05, 0.10, 0.05, 0.05, 0.05, 0.10 };        HashMap<Integer, double[][]> map = optional_bst(p, q, 5);        double e[][] = map.get(1);        for (int i = 0; i < e.length; i++) {            for (int j = 0; j < e[i].length; j++) {                if (e[i][j] > 0) {                    // 按四舍五入保留两位小数                    BigDecimal b = new BigDecimal(e[i][j]);                    System.out.println(                            "e[" + i + "]" + "[" + j + "]=" + b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());                }            }        }

到此为止，最佳二叉搜索树的代价以及分割点已经全部得到，现在我们需要打印输出二叉搜索的结构，java代码如下：

/**     * 打印最优二叉树的结构     *      * @param root     *            : 最优根结点     * @param i     *            :子树起点     * @param j     *            :子树终点     */    public static void print_construct_optimal_bst(double root[][], int i, int j, int r) {        int rootChild = (int) root[i][j];        if (rootChild == root[1][5]) {            System.out.println("K" + rootChild + "为根");            print_construct_optimal_bst(root, i, rootChild - 1, rootChild);// 左子树            print_construct_optimal_bst(root, rootChild + 1, j, rootChild);// 右子树            return;// 根只有一个，所以需要一个return        }        if (j < i - 1) {            return;        } else if (j == i - 1) {// 这里是伪关键字节点，必为叶子结点            if (j < r) {                System.out.println("d" + j + "为" + "K" + r + "的左孩子");            } else {                System.out.println("d" + j + "为" + "K" + r + "的右孩子");            }            return;        } else {// 这里关键字节点，必为非叶子结点            if (rootChild < r) {                System.out.println("K" + rootChild + "为" + "K" + r + "的左孩子");            } else {                System.out.println("K" + rootChild + "为" + "K" + r + "的右孩子");            }        }        print_construct_optimal_bst(root, i, rootChild - 1, rootChild);        print_construct_optimal_bst(root, rootChild + 1, j, rootChild);    }

对于这个算法，需要明白二叉树的结构特点。

基本完成，算法导论上面的算法具体实现。