大数据结构作业3.docx

大数据结构作业3.docx

《大数据结构作业3.docx》由会员分享，可在线阅读，更多相关《大数据结构作业3.docx（18页珍藏版）》请在冰豆网上搜索。

大数据结构作业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;i

if（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;i

if（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;i

if（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所示图的相邻矩阵表示。

123456

（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树。

5

11.5对于图11.26所示的图，给出从顶点1开始BFS树

4

2

1

6

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的每对顶点间最短路径算法的结果。

0-path

123456

1-path

123456

2-path

123456

3-path

123456

4-path

123456

5

123456

-path

123456

6-path

11.18对于图11.26中的图，给出从顶点3开始使用Prim的MST算法时各个边的访问顺序，并给出最终的MST。

各个边的访问顺序：

（3,2）（2,4）（2,1）（1,6）（6,5）

最终MST：

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