数据结构作业3.docx
《数据结构作业3.docx》由会员分享，可在线阅读，更多相关《数据结构作业3.docx（16页珍藏版）》请在冰豆网上搜索。
数据结构作业3
第9章检索的作业
9.6假定值A到H存储在一个自组织线性表中，开始按照升序存放。
对于9.2小节建议的三种自组织启发式规则，按照下面顺序访问线性表，给出结果线性表和需要的比较总数。
DHHGHEGHGHECEHG
（1）频率计数自组织线性表启发式规则：
ABCDEFGH比较次数
D:
DABCEFGH4
H:
DHABCEFG8
H:
HDABCEFG2
G:
HDGABCEF8
H:
HDGABCEF1
E：
HDGEABCF7
G:
HGDEABCF3
H:
HGDEABCF1
G:
HGDEABCF2
H:
HGDEABCF1
E:
HGEDABCF4
C:
HGEDCABF7
E:
HGEDCABF3
H:
HGEDCABF1
G:
HGEDCABF2
比较总数=54
（2）移至前端自组织线性表启发式规则：
ABCDEFGH比较次数
D:
DABCEFGH4
H:
HDABCEFG8
H:
HDABCEFG1
G:
GHDABCEF8
H:
HGDABCEF2
E：
EHGDABCF7
G:
GEHDABCF3
H:
HGEDABCF3
G:
GHEDABCF2
H:
HGEDABCF2
E:
EHGDABCF3
C:
CEHGDABF7
E:
ECHGDABF2
H:
HECGDABF3
G:
GHECDABF4
比较总数=59
（3）转置自组织线性表启发式规则：
ABCDEFGH比较次数
D:
ABDCEFGH4
H:
ABDCEFHG8
H:
ABDCEHFG7
G:
ABDCEHGF8
H:
ABDCHEGF6
E：
ABDCEHGF6
G:
ABDCEGHF7
H:
ABDCEHGF7
G:
ABDCEGHF7
H:
ABDCEHGF7
E:
ABDECHGF5
C:
ABDCEHGF5
E:
ABDECHGF5
H:
ABDEHCGF6
G:
ABDEHGCF7
比较总数=95
9.8编写一个算法，实现频率计数自组织线性表启发式规则，假定线性表使用数组实现。
特别是编写一个函数FreqCount，它把要检索的值作为输入，并且相应地调整线性表。
如果值不在线性表中，就把它添加到线性表的最后，其频率计数是1。
算法思想：
按顺序访问记录，每访问一条记录，该记录的访问数加1，如果该记录的访问数已经大于它前面记录的访问数，这条记录就在线性表中与前面的记录交换。
伪代码：
template
voidFreqCount（ElemA[],intcount[]）
{
intn=0;
while（（intval=GETNEXT（））!
=DONE）
{
for（i=0;iif（A[i]==val）break;
elseif（i==n）
{
A[n]=val;
count[n++]=1;
}
else
{
count[i]++;
while（（i>0）&&（count[i]>count[i-1]））
{
swap（A[i],A[i-1]）;
swap（count[i],count[i-1]）;
}
}
}
}
9.9编写一个算法，实现移至前端自组织线性表启发式规则，假定线性表使用数组实现。
特别是编写一个函数MoveToFront，它把要检索的值作为输入，并且相应地调整线性表。
如果值不在线性表中，就把它添加到线性表的开始位置。
算法思想：
按顺序访问记录，每找到一个记录就把它放到线性表的最前面，而把其他记录后退一个位置。
伪代码：
template
voidMoveToFront（ElemA[]）
{
intn=0;
while（（intval=GETNEXT（））!
=DONE）
{
for（i=0;iif（A[i]==val）break;
if（i==n）A[n]=val;
while（i>0）
swap（A[i],A[0]）;
}
}
9.10编写一个算法，实现转置自组织线性表启发式规则，假定线性表使用数组实现。
特别是编写一个函数transpose，它把要检索的值作为输入，并且相应地调整线性表。
如果值不在线性表中，就把它添加到线性表的最后。
算法思想：
按顺序访问记录，把找到的记录与它在线性表中的前一条记录交换位置。
伪代码：
template
voidtanspose（ElemA[]）
{
intn=0;
while（（intval=GETNEXT（））!
=DONE）
{
for（i=0;iif（A[i]==val）break;
if（i==n）A[n]=val;
While（i!
=0）
swap（A[i],A[i-1]）;
}
}
*设散列函数为h（K）=Kmod7,闭散列表的地址空间为0,…,6,开始时散列表为空,用线性探查法解决冲突,请画出依次插入键值23,14,9,6,30,12,18后的散列表。
h（23）=2h（14）=0h（9）=2h（6）=6h（30）=2h（12）=5h（18）=4
0
14
1
18
2
23
3
9
4
30
5
12
6
6
9.16使用闭散列，利用双散列方法解决冲突，把下面的关键码插入到一个有13个槽的散列表中（槽从0到12编号）。
使用的散列函数H1和H2在下面定义。
给出插入8个关键码值后的散列表。
一定要说明如何使用H1和H2进行散列。
函数Rev（k）颠倒10进制数k各个位的数字，例如，Rev（37）=73，Rev（7）=7。
H1（k）=kmod13。
H2（k）=（Rev（k+1）mod11）。
关键码：
2,8,31,20,19,18,53,27
H1
（2）=2H2
（2）=3放在位置2
H1（8）=8H2（8）=9放在位置8
H1（31）=5H2（31）=1放在位置5
H1（20）=7H2（20）=1放在位置7
H1（19）=6H2（19）=2放在位置6
H1（18）=5H2（18）=3放在位置5，但位置5已经有数据，5+3=8，位
置8也有数据8+3=11，放在位置11
H1（53）=1H2（53）=1放在位置53
H1（27）=1H2（27）=5放在位置1，但位置1已经有数据，1+5=6，位
置6也有数据，6+5=11，位置11也有数据，
11+5=3，放在位置3
0
1
53
2
2
3
27
4
5
31
6
19
7
20
8
8
9
10
11
18
12
第11章图的作业
11.3（a）画出图11.26所示图的相邻矩阵表示。
（b）画出这个图的邻接表表示。
1->2（10）->4（20）->6
（2）->\
2->1（10）->3（3）->4（5）->\
3->2（3）->5（15）->\
4->1（20）->2（5）->5（11）->6（10）->\
5->3（15）->4（11）->6（3）->\
6->1
（2）->4（10）->5（3）->\
11.4对于图11.26所示的图，给出从顶点1开始DFS树。
11.5对于图11.26所示的图，给出从顶点1开始BFS树
5
11.8对于图11.26中的图，给出从顶点4出发，使用Dijkstra最短路径算法产生的最短路径表。
请像图11.18所示那样，每处理一个顶点时给出相应D值。
1
2
3
4
5
6
初始
∞
∞
∞
0
∞
∞
处理4
20
5
∞
0
11
10
处理2
15
5
8
0
11
10
处理3
15
5
8
0
11
10
处理5
15
5
8
0
11
10
处理6
15
5
8
0
11
10
处理1
15
5
8
0
11
10
顶点4到顶点1的最短路径为15；
顶点4到顶点2的最短路径为5；
顶点4到顶点3的最短路径为8；
顶点4到顶点4的最短路径为0；
顶点4到顶点5的最短路径为11；
顶点4到顶点6的最短路径为10。
11.12编写一个算法确定一个有|V|个顶点的有向图是否包含回路。
算法的时间代价应该是Θ（|V|+|E|）。
算法思想：
用广度优先拓扑排序的方法，首先访问所有的边，计算指向每个顶点的边数，将所有没有先决条件的顶点放入队列，然后开始处理队列，当从队列中删除一个顶点时，把它打印出来，同时将其所有相邻顶点的先决条件计数减1，当某个相邻顶点的计数为0时，就将其放入队列，如果还有顶点未被打印，而队列已经为空，则图中包含回路。
伪代码：
voidtopsort（Graph*G,Queue）
{
intCount[G->n（）];
intv,w;
for（v=0;vn（）;v++）Count[v]=0;
for（v=0;vn（）;v++）
for（w=G->first（v）;wn;w=G->next（v,w））
Count[w]++;
for（v=0;vn（）;v++）
if（Count[v]==0;）
Q->enqueue（v）;
while（Q->length（）!
=0）
{
Q->dequeue（v）;
printout（v）;
for（w=G->first（v）;wn（）;w=G->next（v,w））
{
Count[w]--;
if（Count[w]==0）
Q->enqueue（w）;
}
}
}
11.13编写一个算法确定一个有|V|个顶点的无向图是否包含回路。
算法的时间代价应该是Θ（|V|）。
算法思想：
用深度优先搜索的方法，如果遇到已经访问过的结点，则说明该无向图包含回路。
伪代码：
voidDFS（intmap[][],inta,intdep）
{
{
if（dep>1&&a==v）
{
Printout（"有环路"）;
return;
}
for（i=0;i{
if（map[a][i]==1）
DFS（map,i,dep++）;
}
}
voidmain（）
{
DFS（map,v,1）;
}
11.15对于图11.26所示的图，给出使用Floyd的每对顶点间最短路径算法的结果。
010∞20∞2
10035∞∞
∞30∞15∞
205∞01110
∞∞151103
2∞∞1030
123456
1
2
3
4
5
6
0-path
1-path
2-path
3-path
4-path
5-path
6-path
11.18对于图11.26中的图，给出从顶点3开始使用Prim的MST算法时各个边的访问顺序，并给出最终的MST。
各个边的访问顺序：
（3,2）（2,4）（2,1）（1,6）（6,5）
最终MST：
1
2
3
4
6
11.19对于图11.26中的图，给出使用Kauskal的MST算法时各个边的访问顺序，每当把一条边添加到MST时，等价类数组的结果是什么（如图6.7那样显示数组内容）？
初始状态
处理边（1,6）
处理边（2,3）
处理边（5,6）
处理边（2,4）
处理边（1,2）
等价类数组结果：
123456
初始状态-1-1-1-1-1-1
处理边（1，6）-1-1-1-1-11
处理边（2，3）-1-12-1-11
处理边（5，6）-1-12-111
处理边（2，4）-112-111
处理边（1，2）-112111
升级会员 