最优二叉搜索树
计算机算法试题（含答案）
计算机算法试题（含答案）算法设计与分析试卷一、填空题（20分，每空2分）1、算法的性质包括输入、输出、＿＿＿、有限性。
2、动态规划算法的基本思想就将待求问题＿＿＿＿＿、先求解子问题，然后从这些子问题的解得到原问题的解。
3、设计动态规划算法的4个步骤：（1）找出＿＿＿＿，并刻画其结构特征。
（2）＿＿＿＿＿＿＿。
（3）＿＿＿＿＿＿＿。
（4）根据计算最优值得到的信息，＿＿＿＿＿＿＿。
4、流水作业调度问题的johnson算法：（1）令N1=＿＿＿,N2={i|ai>=bj};（2）将N1中作业依ai的＿＿＿。
5、对于流水作业高度问题，必存在一个最优调度π，使得作业π（i）和π（i+1）满足Johnson不等式＿＿＿＿＿。
6、最优二叉搜索树即是＿＿＿的二叉搜索树。
二、综合题（50分）1、当（a1,a2,a3,a4,a5,a6）=(-2,11,-4,13,-5,-2)时，最大子段和为∑ak(2<=k<=4)＿＿＿＿（5分）2、由流水作业调度问题的最优子结构性质可知，T（N，0）=＿＿＿＿＿＿（5分）3、最大子段和问题的简单算法(10分)int maxsum(int n,int *a,int & bestj){intsum=0;for (int i=1;i<=n;i++)for (int j=i;j<=n;j++)int thissum=0;for(int k=i;k<=j;k++)＿＿＿＿＿;if(thissum>sum){sum=thissum;＿＿＿＿＿＿；bestj=j;}} return sum;}4、设计最优二叉搜索树问题的动态规划算法OptimalBinarysearchTree (15分)Void OptimalBinarysearchTree(int a,int n,int * * m, int* * w){for(int i=0;i<=n;i++) {w[i+1][i]=a[i]; m[i+1][i]=＿＿＿＿;}for(int r=0;r<n;r++)< p="">for(int i=1;i<=n-r;i++){int j=i+r;w[i][j]=w[i][j-1]+a[j]+b[j];m[i][j]=＿＿＿＿＿＿;s[i][j]=i;for(int k=i+1;k<=j;k++){int t=m[i][k-1]+m[k+1][j];if(＿＿＿＿＿) {m[i][j]=t; s[i][j]=k;}}m[i][j]=t; s[i][j]=k;}}5、设n=4, (a1,a2,a3,a4)=(3,4,8,10), (b1,b2,b3,b4)=(6,2,9,15) 用两种方法求4个作业的最优调度方案并计算其最优值（15分）三、简答题（30分）1、将所给定序列a[1:n]分为长度相等的两段a[1:n/2]和a[n/2+1:n]，分别求出这两段的最大子段和，则a[1:n]的最大子段和有哪三种情形(10分)答：2、由0——1背包问题的最优子结构性质，可以对m（i,j）建立怎样的递归式 (10分)3、0——1背包求最优值的步骤分为哪几步（10分）参考答案：填空题：确定性分解成若干个子问题最优解的性质递归地定义最优值以自底向上的方式计算出最优值构造最优解 {i|ai<="" p="">依bi的非增序排序min{bπ(i),aπ(i+1)}≥min{bπ(i+1),aπ(i)}最小平均查找长度综合题：20 min{ai+T(N-{i},bi)}(1=<i<=n) 0="" besti="i" m[i+1][j]="" p="" t<m[i][j]<="" thissum+="a[k]">法一：min(ai,bj)<=min(aj,bi)因为 min(a1,b2)<=min(a2,b1)所以1→2 (先1后2)由 min(a1,b3)<=min(a3,b1)得1→3 （先1后3）同理可得：最后为1→3→4→2法二：johnson算法思想N1＝{1，3，4} N2＝{2}N11＝{1，3，4} N12＝{2}所以N11→N12得：1→3→4→2简答题：1 、（1）a[1:n]的最大子段和与a[1:n/2]的最大子段和相同。
动态规划-最优二叉搜索树
动态规划-最优⼆叉搜索树摘要： 本章介绍了⼆叉查找树的概念及操作。
主要内容包括⼆叉查找树的性质，如何在⼆叉查找树中查找最⼤值、最⼩值和给定的值，如何找出某⼀个元素的前驱和后继，如何在⼆叉查找树中进⾏插⼊和删除操作。
在⼆叉查找树上执⾏这些基本操作的时间与树的⾼度成正⽐，⼀棵随机构造的⼆叉查找树的期望⾼度为O(lgn)，从⽽基本动态集合的操作平均时间为θ(lgn)。
1、⼆叉查找树 ⼆叉查找树是按照⼆叉树结构来组织的，因此可以⽤⼆叉链表结构表⽰。
⼆叉查找树中的关键字的存储⽅式满⾜的特征是：设x为⼆叉查找树中的⼀个结点。
如果y是x的左⼦树中的⼀个结点，则key[y]≤key[x]。
如果y是x的右⼦树中的⼀个结点，则key[x]≤key[y]。
根据⼆叉查找树的特征可知，采⽤中根遍历⼀棵⼆叉查找树，可以得到树中关键字有⼩到⼤的序列。
介绍了⼆叉树概念及其遍历。
⼀棵⼆叉树查找及其中根遍历结果如下图所⽰：书中给出了⼀个定理：如果x是⼀棵包含n个结点的⼦树的根，则其中根遍历运⾏时间为θ(n)。
问题：⼆叉查找树性质与最⼩堆之间有什么区别？能否利⽤最⼩堆的性质在O(n)时间内，按序输出含有n个结点的树中的所有关键字？2、查询⼆叉查找树 ⼆叉查找树中最常见的操作是查找树中的某个关键字，除了基本的查询，还⽀持最⼤值、最⼩值、前驱和后继查询操作，书中就每种查询进⾏了详细的讲解。
（1）查找SEARCH 在⼆叉查找树中查找⼀个给定的关键字k的过程与⼆分查找很类似，根据⼆叉查找树在的关键字存放的特征，很容易得出查找过程：⾸先是关键字k与树根的关键字进⾏⽐较，如果k⼤⽐根的关键字⼤，则在根的右⼦树中查找，否则在根的左⼦树中查找，重复此过程，直到找到与遇到空结点为⽌。
例如下图所⽰的查找关键字13的过程：（查找过程每次在左右⼦树中做出选择，减少⼀半的⼯作量）书中给出了查找过程的递归和⾮递归形式的伪代码：1 TREE_SEARCH(x,k)2 if x=NULL or k=key[x]3 then return x4 if(k<key[x])5 then return TREE_SEARCH(left[x],k)6 else7 then return TREE_SEARCH(right[x],k)1 ITERATIVE_TREE_SEARCH(x,k)2 while x!=NULL and k!=key[x]3 do if k<key[x]4 then x=left[x]5 else6 then x=right[x]7 return x（2）查找最⼤关键字和最⼩关键字 根据⼆叉查找树的特征，很容易查找出最⼤和最⼩关键字。
最优二叉树（哈夫曼树）的构建及编码
最优⼆叉树（哈夫曼树）的构建及编码参考：数据结构教程（第五版）李春葆主编⼀，概述1，概念 结点的带权路径长度： 从根节点到该结点之间的路径长度与该结点上权的乘积。
树的带权路径长度： 树中所有叶结点的带权路径长度之和。
2，哈夫曼树（Huffman Tree） 给定 n 个权值作为 n 个叶⼦结点，构造⼀棵⼆叉树，若该树的带权路径长度达到最⼩，则称这样的⼆叉树为最优⼆叉树，也称为哈夫曼树。
哈夫曼树是带权路径长度最短的树，权值较⼤的结点离根较近。
⼆，哈夫曼树的构建1，思考 要实现哈夫曼树⾸先有个问题摆在眼前，那就是哈夫曼树⽤什么数据结构表⽰？ ⾸先，我们想到的肯定数组了，因为数组是最简单和⽅便的。
⽤数组表⽰⼆叉树有两种⽅法： 第⼀种适⽤于所有的树。
即利⽤树的每个结点最多只有⼀个⽗节点这种特性，⽤ p[ i ] 表⽰ i 结点的根节点，进⽽表⽰树的⽅法。
但这种⽅法是有缺陷的，权重的值需要另设⼀个数组表⽰；每次找⼦节点都要遍历⼀遍数组，⼗分浪费时间。
第⼆种只适⽤于⼆叉树。
即利⽤⼆叉树每个结点最多只有两个⼦节点的特点。
从下标 0 开始表⽰根节点，编号为 i 结点即为 2 * i + 1 和 2 * i + 2，⽗节点为 ( i - 1) / 2，没有⽤到的空间⽤ -1 表⽰。
但这种⽅法也有问题，即哈夫曼树是从叶结点⾃下往上构建的，⼀开始树叶的位置会因为⽆法确定⾃⾝的深度⽽⽆法确定，从⽽⽆法构造。
既然如此，只能⽤⽐较⿇烦的结构体数组表⽰⼆叉树了。
typedef struct HTNode // 哈夫曼树结点{double w; // 权重int p, lc, rc;}htn;2，算法思想 感觉⽐较偏向于贪⼼，权重最⼩的叶⼦节点要离根节点越远，⼜因为我们是从叶⼦结点开始构造最优树的，所以肯定是从最远的结点开始构造，即权重最⼩的结点开始构造。
所以先选择权重最⼩的两个结点，构造⼀棵⼩⼆叉树。
然后那两个最⼩权值的结点因为已经构造完了，不会在⽤了，就不去考虑它了，将新⽣成的根节点作为新的叶⼦节加⼊剩下的叶⼦节点，⼜因为该根节点要能代表整个以它为根节点的⼆叉树的权重，所以其权值要为其所有⼦节点的权重之和。
盘点常用的搜索树
盘点常⽤的搜索树树的典型应⽤有很多，⽐如计算机的⽂件系统就是⼀棵树，根⽬录就是根节点。
树的重要应⽤之⼀就是搜索树，搜索树通常分为⼆叉搜索树和多路搜索树。
⼆叉搜索树⼆叉搜索树是⼀颗有序的树，每个结点不⼩于其左⼦树任意结点的值，不⼤于右⼦树任意结点的值。
⼆叉搜索树还有⼀个有趣的特性，它的中序遍历得到的是有序数列。
⼆叉搜索树能提⾼搜索的效率，搜索次数最多是树的深度次，最少能到log(n)。
搜索树有搜索，插⼊，删除等操作。
搜索即搜索整棵树，查找是否有匹配的节点；还有搜索最⼤值和最⼩值操作，最⼤值在树的最右侧，最⼩值在最左侧，因此都很好实现。
treenode find(tree T,int val){ /*搜索操作*/if(T==NULL) return NULL;if(T->data > val)return find(T->left,val);else if(T->data < val)return find(T->right,val);elsereturn T;}插⼊，也是采⽤递归实现，插⼊的结点都放到了叶⼦节点。
treenode insert(tree T,int val){if(T==NULL) {T=(treenode)malloc(sizeof(struct node));T->data=val;T->right=T->left=NULL;}else if(T->data >= val)T->left = insert(T->left,val);elseT->right = insert(T->right,val);return T;}删除，这种操作⽐较复杂，因为可能会破坏BST的规则，需要进⾏调整。
删除操作分⼏种情况：1）当删除的结点是叶⼦节点，直接删除即可，如删除下图中的7结点；2）当删除⾮叶节点，且该节点只有⼀个⼦节点时，我们可以删除该节点，并让其⽗节点连接到它的⼦节点即可；如删除8结点，直接让5结点连接到7即可；3）当⾮叶节点，且有两个⼦节点时，可以删除该节点，然后抓出左⼦树中最⼤的元素(或者右树中最⼩的元素)，来补充被删元素产⽣的空缺。
(陈慧南 第3版)算法设计与分析——第7章课后习题答案
③ 其余元素
w[0][2] q[2] p[2] w[0][1] 15
k 1: c[0][0] c[1][2] c[0][2] min k 2 : c[0][1] c[2][2] w[0][2] 22 r[0][2] 2
17000
s[0][2]
0
m[1][3]
min
k k
1: m[1][1] m[2][3] 2 : m[1][2] m[3][3]
p1 p2 p4 p1 p3 p4
10000
s[1][3]
2
m[1][3]
min
k k
0 : m[0][0] m[1][3] 1: m[0][1] m[2][3]
第七章课后习题
姓名：赵文浩 学号：16111204082 班级：2016 级计算机科学与技术 7-1 写出对图 7-19 所示的多段图采用向后递推动态规划算法求解时的计算过程。
3
1
3
1
6
5
0
2
6
6
3
4
4 6
5
2
7
8
3
2
8
5
2
7
解析：
V 5 cost(5,8) 0 d (5,8) 8
V4
cos t(4, 6) minc(6,8) cos t(5,8) 7 cos t(4, 7) minc(7,8) cos t(5,8) 3
k 1: c[0][0] c[1][3] c[0][3] min k 2 : c[0][1] c[2][3] w[0][3] 25
最优二叉树
哈夫曼编码的另一种表示： 1.00
0 0.40 0 g 0.21 1
1
b 0.19
0
0.28 0 0.17 1
0.60 1 e 0.32
0.11 0 1
0
1 d 0.07 0.06
h 0.10
哈夫曼编码树
a
0.05
0 f 0.03 1 c 0.02
练习题：设计哈夫曼编码，通信中可能有8种字符,其频率 分别为:0.05,0.29,0.07,0.08,0.14,0.23,0.03,0.11
0 d
1
0
i 0 a
1
1 n
Huffman编码结果：d=0, i=10, a=110, n=111 WPL=1bit×7＋2bit×5+3bit(2+4)=35（小于等长码的WPL=36） 特征：每一码不会是另一码的前缀，译码时唯一，不会错! Huffman编码也称为前缀码
Huffman编码
哈夫曼编码的基本思想是——— 出现概率大的信息用短码，概率小的用长码
最佳判定方法
Y Y E Y D Y a<60 N a<70 N C Y B Y D 70a<80 N 80a<90 N 60a<70 N
a<80
N a<90 N A
Y
E
C
Y B
a<60
N A
(b)WPL=40x1+30x2+15x3+5x4+10x4=205
(a)WPL=10x4+30x4+40x3+15x2+5x1=315
void Select (HuffmanTree HT,int t,int&s1,int&s2) {//在HT[1...t]中选择parent为0且权值最小的两个结点，其 序号分别为s1和s2 int i, m, n; m=n=100000; for(i=1;i<=t;i++) {if(HT[i].parent==0&&(HT[i].weight<m||HT[i].weight<n)) if(m<n) { n=HT[i].weight ; s2=i ; } else { m=HT[i].weight ; s1=i ; } } if(s1>s2) //s1放较小的序号 {i=s1;s1=s2;s2=i;} }
算法分析与设计-屈婉玲-第6周
时间复杂度：O(n)
10
小结
• • • • • • 图像变位存储问题的建模 子问题边界的界定 递推方程及初值 伪码 标记函数与解的追踪 时间复杂度
最大子段和
最大子段和
问题：给定n个数(可以为负数)的序列
(a1, a2, ... , an) j ak } 求 max{0, 1max k i i jn
1
L0
4 2 3
L3
6 5
L4 L6 L5
2
L1 L2
二叉树的检索方法
1. 初始，x与根元素比较； 2. x < 根元素，递归进入左子树； 3. x > 根元素，递归进入右子树； 4. x = 根元素，算法停止，输出 x； 5. x 到叶结点算法停止，输出 x不在数组.
4 2 1
L0
x=3.5 6
255 255 255 255 255 255
1
2
S[5]=50 S[4]=42 S[3]=23
10
1×2＋11
1 1 2
63 57 58
2
2×2＋11
2
3×8＋11
1
S[2]=19
10
4×8＋11
1 1 2
62 66
2
S[1]=15
10
5×8＋11
6×8＋11
59
9
追踪解
算法 Traceback ( n , l ) 输入：数组 l 输出：数组 C 1. j ← 1 // j 为正在追踪的段数 2. while n ≠ 0 do 第 j段 3. C[ j ] ← l [n] 长度 4. n ← n－ l [n] 5. j ← j + 1 C[ j ]：从后向前追踪的第 j段的长度
介绍二叉排序树的结构和特点
介绍二叉排序树的结构和特点二叉排序树，也称为二叉搜索树或二叉查找树，是一种特殊的二叉树结构，其主要特点是左子树上的节点都小于根节点，右子树上的节点都大于根节点。
在二叉排序树中，每个节点都存储着一个关键字，而且所有的关键字都不相同。
二叉排序树的结构如下：1.根节点：二叉排序树的根节点是整个树的起始点，其关键字是最大的。
2.左子树：根节点的左子树包含着小于根节点关键字的所有节点，且左子树本身也是一个二叉排序树。
3.右子树：根节点的右子树包含着大于根节点关键字的所有节点，且右子树本身也是一个二叉排序树。
二叉排序树的特点如下：1.有序性：二叉排序树的最重要特点是有序性。
由于左子树上的节点都小于根节点，右子树上的节点都大于根节点，所以通过中序遍历二叉排序树，可以得到一个有序的序列。
2.快速查找：由于二叉排序树是有序的，所以可以利用二叉排序树进行快速查找操作。
对于给定的关键字，可以通过比较关键字与当前节点的大小关系，逐步缩小查找范围，最终找到目标节点。
3.快速插入和删除：由于二叉排序树的有序性，插入和删除操作比较简单高效。
插入操作可以通过比较关键字的大小关系，找到合适的位置进行插入。
删除操作可以根据不同情况，分为三种情况处理：删除节点没有子节点、删除节点只有一个子节点和删除节点有两个子节点。
4.可以用于排序：由于二叉排序树的有序性，可以利用二叉排序树对一组数据进行排序。
将数据依次插入二叉排序树中，然后再通过中序遍历得到有序序列。
二叉排序树的优缺点如下：1.优点：(1)快速查找：通过二叉排序树可以提供快速的查找操作，时间复杂度为O(log n)。
(2)快速插入和删除：由于二叉排序树的有序性，插入和删除操作比较简单高效。
(3)可以用于排序：通过二叉排序树可以对一组数据进行排序，时间复杂度为O(nlog n)。
2.缺点：(1)受数据分布影响：如果数据分布不均匀，可能导致二叉排序树的高度增加，从而降低了查找效率。
(2)不适合大规模数据：对于大规模数据，二叉排序树可能会导致树的高度过高，从而影响了查找效率。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include<stdio.h>
#include<stdlib.h>
#define max 9999
void OptimalBST(int,float*,float**,int**);
void OptimalBSTPrint(int,int,int**);
void main()
{
int i,num;
FILE *point;
//所有数据均从2.txt中获取，2.txt中第一个数据表示节点个数；从第二个数据开始表示各个节点的概率
point=fopen("2.txt","r");
if(point==NULL)
{
printf("cannot open 2.txt.\n");
exit(-1);
}
fscanf(point,"%d",&num);
printf("%d\n",num);
float *p=(float*)malloc(sizeof(float)*(num+1));
for(i=1;i<num+1;i++)
fscanf(point,"%f",&p[i]);
//创建主表；
float **c=(float**)malloc(sizeof(float*)*(num+2));
for(i=0;i<num+2;i++)
c[i]=(float*)malloc(sizeof(float)*(num+1));
//创建根表；
int **r=(int**)malloc(sizeof(int*)*(num+2));
for(i=0;i<num+2;i++)
r[i]=(int*)malloc(sizeof(int)*(num+1));
//动态规划实现最优二叉查找树的期望代价求解。
OptimalBST(num,p,c,r);
printf("该最优二叉查找树的期望代价为：%f \n",c[1][num]);
//给出最优二叉查找树的中序遍历结果；
printf("构造成的最优二叉查找树的中序遍历结果为：");
OptimalBSTPrint(1,4,r);
}
void OptimalBST(int num,float*p,float**c,int**r)
{
int d,i,j,k,s,kmin;
float temp,sum;
for(i=1;i<num+1;i++)//主表和根表元素的初始化
{
c[i][i-1]=0;
c[i][i]=p[i];
r[i][i]=i;
}
c[num+1][num]=0;
for(d=1;d<=num-1;d++)//加入节点序列
{
for(i=1;i<=num-d;i++)
{
j=i+d;
temp=max;
for(k=i;k<=j;k++)//找最优根
{
if(c[i][k-1]+c[k+1][j]<temp)
{
temp=c[i][k-1]+c[k+1][j];
kmin=k;
}
}
r[i][j]=kmin;//记录最优根
sum=p[i];
for(s=i+1;s<=j;s++)
sum+=p[s];
c[i][j]=temp+sum;
}
}
}
//采用递归方式实现最优根的输出，最优根都是保存在r[i][j]中的。
void OptimalBSTPrint(int first,int last,int**r)
{
int k;
if(first<=last)
{
k=r[first][last];
printf("%d ",k);
OptimalBSTPrint(first,k-1,r);
OptimalBSTPrint(k+1,last,r);
}
}。