数据结构作业.docx
《数据结构作业.docx》由会员分享,可在线阅读,更多相关《数据结构作业.docx(19页珍藏版)》请在冰豆网上搜索。
数据结构作业
数据结构作业(3)(总14页)
第9章检索的作业
假定值A到H存储在一个自组织线性表中,开始按照升序存放。
对于小节建议的三种自组织启发式规则,按照下面顺序访问线性表,给出结果线性表和需要的比较总数。
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
编写一个算法,实现频率计数自组织线性表启发式规则,假定线性表使用数组实现。
特别是编写一个函数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]);
}
}
}
}
编写一个算法,实现移至前端自组织线性表启发式规则,假定线性表使用数组实现。
特别是编写一个函数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]);
}
}
编写一个算法,实现转置自组织线性表启发式规则,假定线性表使用数组实现。
特别是编写一个函数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
使用闭散列,利用双散列方法解决冲突,把下面的关键码插入到一个有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章图的作业
(a)画出图所示图的相邻矩阵表示。
(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)->\
对于图所示的图,给出从顶点1开始DFS树。
1
6
3
5
对于图所示的图,给出从顶点1开始BFS树
4
2
1
6
3
5
对于图中的图,给出从顶点4出发,使用Dijkstra最短路径算法产生的最短路径表。
请像图所示那样,每处理一个顶点时给出相应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。
编写一个算法确定一个有|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);
}
}
}
编写一个算法确定一个有|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);
}
对于图所示的图,给出使用Floyd的每对顶点间最短路径算法的结果。
0-path
1-path
2-path
3-path
4-path
5-path
123456
6-path
对于图中的图,给出从顶点3开始使用Prim的MST算法时各个边的访问顺序,并给出最终的MST。
各个边的访问顺序:
(3,2)(2,4)(2,1)(1,6)(6,5)
最终MST:
对于图中的图,给出使用Kauskal的MST算法时各个边的访问顺序,每当把一条边添加到MST时,等价类数组的结果是什么(如图那样显示数组内容)
初始状态
处理边(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