问题来源:
我们在实现英语到汉语时,我们需要查询英语文本中的每一个单词所对用的汉语。我们此时可以构建一个二叉搜索树,将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-1
e[i,j] = q[i-1]
// i <= j
e[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 HashMapdouble[][]> optional_bst(double p[], double q[], int n) {
// 存放回返的两个数组的集合
HashMapdouble[][]> map = new HashMapdouble[][]>();
// 用这个二维数组保存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 };
HashMapdouble[][]> 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);
}
对于这个算法,需要明白二叉树的结构特点。
基本完成,算法导论上面的算法具体实现。