数据结构课程设计(散列表计算程序相近度)

数据结构课程设计报告

对于两个C程序，设计并实现两种不同的基于散列表的检测算法,

计算两个程序的相近度，并分析比较两种算法的效率。

—散列表

班级：软件112班

姓名：刘路峰

指导教师：兰红

成绩：

立月理J大学信息工程学院

2013年1月6日

目录

1需求分析........................................................3

1.1主要任务...............................................................3

1.2课题要求...............................................................3

1.3主要功能...............................................................3

1.4主要工作...............................................................3

1■5重点解决问题......................................................3

2概要设计..................................................4

2.1抽象数据...............................................................4

2.2头文件及宏、结构体定义................................................6

2.3主程序流程.............................................................7

2.4各程序模块层次关系....................................................7

3详细设计........................................................8

3.1模块实现..............................................................8

3.1.1主要模块(函数)................................................8

3.2主程序流程图..........................................................12

4调试分析........................................................13

4.1遇到的问题...........................................................13

4.1.1关于程序运行时间的计算........................................13

4.2程序代码改进..........................................................14

4.2.1打开文件接收字符部分..........................................14

4.3算法时空分析........................................................16

4.3.1SortKeyO复杂度.................................................16

4.3.20Find()函数复杂度..............................................17

4.3.3CheckKeyword()函数复杂度.......................................17

4.4程序设计回顾........................................................17

4.5经马佥和体会..........................................................18

5测试结果.......................................................20

5.1简单程序测试........................................................20

5.1.1测试文件内容....................................................20

5.1.2程序输入界面....................................................20

5.1.3测试运行结果....................................................21

5.2复杂程序测试..........................................................22

5.2.1测试文件内容....................................................22

5.2.2程序输入界面....................................................23

5.2.3测试运行结果....................................................23

参考文献...........................................................25

附录：源代码.......................................................25

1需求分析

1.1主要任务

对于两个C程序，设计并实现两种不同的基于散列表的检测算法，计算两

个程序的相近度，并分析比较两种算法的效率。

1.2课题要求

1.分别读取两个C程序文件(InFilel.cpp,lnFile2.cpp),识别其中的关键字

并统计频度，分别生成两个文件，保存关键字名称和对应频度(OutFilel.txt,

OutFile2.txt)；

2.自行设计散列函数，分别利用开放地址法和链地址法构建C语言关键字

的散列表。在扫描源程序的过程中，每遇到关键字就查找相应散列表，并累加相

应关键字出现的频度；

3.根据统计的两个程序中关键字不同频度，可以得到两个向量。

1.3主要功能

计算两个程序的相近度，并比较开放地址法和链地址法两种算法的效率

1.4主要工作

1.读取文件中的字符，并对读到的字符串就是否是关键字进行判别；

2.使用散列表存储从文件中读到的关键字；

3.向指定文件中写入得到的关键字和频度；

4.根据公式计算出向量相对距离s；

5.计算相对距离s所用的时间。

1.5重点解决问题

1.过滤注释；

2.读取字符并判断读取到的字符串是否是关键字；

3.关键字的存储。

2概要设计

2.1抽象数据

抽象数据类型定义：

ADT

{

数据对象：两个C程序(文件路径需给出)

基本操作：

InitKey(keykeys[])

初始条件：关键字结构体数组keys己声明

操作结果：初始化关键字结构体数组

OInit(HashTable&HT)

初始条件：开放地址法散列表HT已声明

操作结果：开放地址法初始化散列表

Unit(HashLink&HL)

初始条件：链地址法散列表HL已声明

操作结果：链地址法初始化散列表

CheckKeyword(char*s)

初始条件：字符串数组s已存在，预设关键字数组已存在

操作结果：检查字符串数组s是否是关键字

OFind(HashTable&HT,char*keyword,intkey)

初始条件：开放地址法散列表HT和关键字字符数组keyword已存在

操作结果：返回关键字字符数组keyword的存放位置

OCreateHashList(HashTable&HT,char*keyword)

初始条件：开放地址法散列表HT和关键字字符数组keyword已存在

操作结果：开放地址法将关键字加入哈希表

LCreateHashList(HashLink&HL,char*keyword)

初始条件：链地址法散列表HL和关键字字符数组keyword已存在

操作结果：链地址法将关键字加入哈希表

OpenFile(HashTable&HT,HashLink&HL,charfilename口，intop)

初始条件：开放地址法散列表HT和链地址法散列表HL已初始化，字符数组

filename已指定

操作结果：使用指定的方法构造对应的哈希表(方法由。p变量指定)

OFileWrite(HashTableHT,charfilename口，keykeys[])

初始条件：开放地址法散列表HT已构造，字符数组filename已指定，关键字结

构体数组keys已初始化

操作结果：关键字和其频度写入指定文件同时存储到关键字结构体数组keys中

LFileWrite(HashLinkHL,charfilename[]?keykeys[])

初始条件：开放地址法散列表HL已构造，字符数组filename已指定，关键字结

构体数组keys已初始化

操作结果：关键字和其频度写入指定文件同时存储到关键字结构体数组keys中

SortKey(keykeys[])

初始条件：关键字结构体数组已存在

操作结果：对关键字结构体数组进行排序

ShowKey(keykeyl[],keykey2[])

初始条件：关键字结构体数组keyl和key2已存在

操作结果：显示关键字信息

KeySub(keykeyl口，keykey2[],keykey3[])

初始条件：关键字结构体数组keyl和key2已存在，key3已声明

操作结果：计算keyl和key2构成的两个向量之间的差值并存储于key3中

CalKey(keykeys[])

初始条件：关键字结构体数组keys已存在

操作结果：计算keys构成的向量值

KeySimilar(keykeyl[],keykey2[]jkeykey3[])

初始条件：关键字结构体数组keyl、key2和key3已存在

操作结果：计算keyl和key2构成的向量之间的相对距离s

}ADT

2.2头文件及宏、结构体定义

#include<iostream>

#include<fstream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<ctime>

#include<cmath>

usingnamespacestd;

#defineHASHLEN100〃哈希表长度

#defineKEYMAXLEN5〃关键字最大长度

char*keywords[HASHLEN]={"char'\"do","else","float","for","if","int",

"void","while");

typedefstructHash{〃开放地址法散列表的存储表示

charkeyword[KEYMAXLEN];〃关键字名字

intcount;〃关键字频度

}HTNode,*HashTable;

HashTableHT[HASHLEN];

typedefstructHashNode{〃链地址法散列表的存储表示

charkeyword[KEYMAXLEN];〃关键字名字

intcount;〃关键字频度

structHashNode*next;

}*HashLink;

HashLinkHLfHASHLEN];

typedefstructkey{〃定义关键字结构体

charkeyword[KEYMAXLEN];

intcount;

}；

keykeyl[HASHLEN],key2[HASHLEN],key3[HASHLEN];

2.3主程序流程

图2.3-1主程序流程

2.4各程序模块层次关系

图2.4-1各程序模块层次关系

3详细设计

3.1模块实现

3.1.1主要模块(函数)

3.1.1.1检查字符数组是否是关键字

在检查是否是关键字前，需要预设一个关键字数组，因为这里采用

二分查找法，因此要求关键字是有序的。由于程序中预设关键字有9个,

在此函数中，声明begin变量和end变量并分别置为0和8,即begin代

表第一个关键字,end代表最后一个关键字，先取begin和end的中位数,

如果待检查字符数组大于该中位数代表的关键字，则将begin置为中位

数加1,否则，置end为该中位数，之后重复以上步骤，如果最后比较

的关键字仍不等于待检查字符数组，说明待检查字符数组不是关键字，

返回0,如果相等，说明是关键字，返回1。

模块代码如下：

intCheckKeyword(char*s)//检查$字符数组是否为关键字

{

intiJbegin=0Jend=8;

while(begin<=end)〃折半查找法

(

i=(begin+end)/2;

if(strcmp(keywords[i],s)==0)return1;〃找到返回1

elseif(strcmp(keywords[i]s)>0)

end=i-l;

elseif(strcmp(keywords[i],s)<0)

begin=i+l;

)

return。；//未找到返回。

}

3.1.1.2开放地址法构造哈希表

首先，我们需要构造一个哈希函数，这里构造的哈希函数为：

key=strlen(keyword)%47(即关键字长度对47取余数)

之后，我们需要找到关键字存储的位置，这里调用OFind函数寻找

哈希表中可以存放关键字的位置，找到位置后，接下来需要进行判断，

该位置是否为空(即没有关键字)，因为是使用开放地址法构造，因此，

如果当前位置已有关键字，则必与待存储的关键字相同，因此只需关键

字频度加1即可；如果此位置没有关键字，则需将待存储关键字存储到

该位置，同时对应的频度加1。

模块代码如下：

voidOCreateHashList(HashTable&HT,char"keyword)〃开放地址法构

造哈希表

(

intkey,i,temp;

key=strlen(keyword)%47;〃哈希函数

temp=OFind(HTjkeyword,key);//寻找关键字存放位置

〃如果当前哈希值位置已有元素且当前关键字与其相同

if(temp==key&&strlen(HT[temp].keyword)>0)HT[key].count++;

else

{〃否则将关键字存放于OFind函数返回的te叩值对应位置，同时对应计

数器加1

strcpy(HT[temp].keywordjkeyword);

HT[temp].count++;

)

)

调用的OFind函数代码如下：

intOFind(HashTable&HT,char"keyword,intkey)〃寻找关键字存放

位置

{

inti,flag;

for(i=0;i<HASHLEN;i++)//由于可能有多种情况，所以必须全部比较

.次

{

if(strcmp(HT[i].keywordjkeyword)==0)returni;〃如果找到

相同关键字则返回位置

)

for(i=key;i<HASHLEN;i++)〃未找到则向后搜索空位

if(strlen(HT[i].keyword)==0)returni;〃返回空位的位置

for(i=0;i<key;i++)〃向后搜索未找到空位则从头开始搜索

if(strlen(HT[i].keyword)==0)returni;〃返回空位的位置

)

3.1.1.3链地址法构造哈希表

链地址法构造哈希表的前几步步骤与开放地址法构造哈希表相同，

不同的是，因为链地址法构造哈希表中每个元素必定是存储在其哈希值

对应的位置上的，如果其哈希值对应的位置已有关键字，但该关键字与

待存储关键字不同，这时我们需要在该位置申请一个结点，使用链式存

储的形式把待存储关键字存储起来。

模块代码如下：

voidLCreateHashList(HashLink&HL,char"keyword)〃链地址法构造

哈希表

{

intkey,key=strlen(keyword)%47;〃哈希函数

HashNode*p,*q;p=&HL[key],q=NULL;

if(strlen(p->keyword)!=0)〃当前keyword已存字符

(

while(p!=NULL)//寻找此位置链表是否有与当前关键字相同元素

{

if(strcmp(p->keyword,keyword)==0)〃如果相同

(

p->count++;〃对应计数器加1

return;

)

q=p；〃存储前一个

p=p_>next;〃下一个

}

)

if(p!=&HL[key])p=(HashNode*)malloc(sizeof(HashNode));//$n

果没有相同的，则申请一个空间存放关键字

p->count=i;〃计数器为1

p->next=NULL;〃next指针初始化为空

strcpy(p->keyword,keyword);〃复制字符

if(q!=NULL)q->next=p;〃如果前一个不为空，则前一个next指针指向

P

)

3.1.1.4读取程序文件字符

读取程序文件字符时，需要使用一个字符数组临时存储接收到的字

符，每接收到一个字符就判断此时的字符串是否是关键字，如果不是，

则继续接收，由于关键字是由字母组成的，因此，一旦接收到不是字母

的字符，就需要对数组进行清空，同时应注意注释的忽略。注释忽略方

法为：如果接收到"/"字符，则使用一个字符变量接收下一个字符，如果

是说明是行注释，接下来则使用该变量不断接收字符，直到接收到

换行符为止，如果该字符变量接收到"*"字符，说明是块注释，接下来则

使用该变量不断接收字符，直到接收到"*"字符为止。

说明：这里传入参数op接收选择的方法，开地址法为1,链地址法

为2o

模块代码如下：

voidOpenFile(HashTable&HT,HashLink&HL,charfilename口，int

op)〃打开文件

{

intn,i=0,j=0;FILE*rf;chartemp[100],c;

memset(tempj'\0',sizeof(temp));〃初始化temp数组

rf=fopen(filename,"r");〃读取文件

if(rf==NULL)〃文件读取失败

{printf("%s文件打开失败！\n'\filename);exit(0);)

while(!feof(rf))

{

c=fgetc(rf);if(c<0)break;

if(c=='/，)〃去除注释

{〃读取下一个字符，如果是/说明是行注释，如果是*则是块注释

c=fgetc(rf);

if(c=='/，)〃如果是/

{

while"!=10)〃除非读到换行符，否则继续循环

c=fgetc(rf);

}

elseif(c=='*')〃如果是*字符

{

while(l)

{

if(c==，*')〃如果是*字符

(

c=fgetc(rf);〃判断下一个字符是否是/字符

if(c=='/")break;

)

c=fgetc(rf);

)

}

)

if((c>64&&c<91)||(c>96&&c<123))〃关键字由字母组成

{

temp[i++]=c;temp[i]='\0'；

if(strlen(temp)<=KEYMAXLEN)〃如果当前字符串长度小于

等于关键字最大长度

{

if(CheckKeyword(temp)==l)//是关键字

{

开放地址法

elseLCreateHashList(HL,temp);〃链地址法

memset(temp,',sizeof(temp));〃字符数组清空

i=0;

)

}

}

if(!((c>64&&c<91)||(c>96&&c<123)))

{//读到不是字母，则字符数组清空

memset(temp,'\0',sizeof(temp));i=0;

}

3.2主程序流程图

返回主界而

图3.2主程序流程图

4调试分析

4.1遇到的问题

4.1.1关于程序运行时间的计算

由于是调用clock。函数获取当前时间，通过计算前后时间差得到程序运行时间，但

是后来发现，当测试的程序代码比较短时，计算得到的时间差为0（图4.1.1-1）。

图4.1.1-1执行时间为。

在网上查找资料后，我发现了一种更精确的方法：利用内联汇编计算时间差

（图4.1.1-2）,它可以精确到纳秒（图4.1.1-3）。

36inlineunsigned_int64GetCycleCount()

37{

38_asm_emit0x0F

39asmemit0x31

40}|一

图4.1.1-2内联汇编代码

图4.1.1-3时间差精确到纳秒

不过，内联汇编只能在VisualC++中使用（好像只有VisualC++）,因为VisualC++

内置了内联汇编编译器，如果在或中编译会报错（图）

C-FreeCodeblocks4.1.1-40

桧查文件依赖性...

正在编诏E:\资料\作业\效据结构\基于做列表的程序相近度检测系绫.cpp...______________________________________________________

[Error]E：\资料'作业'数据结构'基于散列表的程序相近度检弼系统.cpp：38：error：expected'Cbefore"_e・iL

[Error]更：\资料\作:It\数据结构,基于散列表的程序相近度检剜系绫.cpp：38：error：expectedasnbodybefore

[Error]E：\资料,作业\敖据结构,基于做列表的程序相近度检剜系统.cpp：38：error：wasnotdeclaredinthisscope

[Error]E：\夷料，作业,数据结构,基于散列恚的程序相近度检弱系统.cpp：38：error：expected'/beforenumericconstant

图4.1.1-4

4.2程序代码改进

4.2.1打开文件接收字符部分

一开始我使用的方法是先接收字符，如果字符为字母，则利用一个循环

并设置一个临时字符数组接收后面的字母，当接收到不是字母的字符时，退

出循环并清空临时字符数组，每接收到一个字符就判断临时字符数组里的字

符串是否是关键字，当达到最大关键字字符长度但此时又不是关键字时清空

临时字符数组。对于注释过滤，则先判断读取的字符是否为‘7''字符，如果

是，则读取下一个字符进行判断属于哪一种注释，如果是"*",说明接下来的

内容是块注释的内容；如果是说明接下来的内容是行注释的内容，之后

进行相应的处理即可。代码如下(主要部分)：

while(!feof(rf))

c=fgetc(rf);if(c<0)break;

if(c=="，)〃去除注释

{〃读取下一个字符，如果是/说明是行注释,如果是*则是块注祥

t=fgetc(rf);

if(t=='/，)//如果是/

{

t=fgetc(rf);〃读取字符

while(t!=10)〃除非读到换行符，否则继续循环

t=fgetc(rf);

}

elseif(t=='*')//如果是*

(

t=fgetc(rf);

while(t!='*')//除非读到*字符，否则继续循环

t=fgetc(rf);

1=千86k(肝)；〃接收'/'字符

}

)

while((c>64&&c<91)||(c>96&&c<123))〃关键字由字母组成

(

temp[i++]=c;〃临时存储字符

if(strlen(temp)<=KEYMAXLEN)〃如果当前字符串长度小于等于

关键字最大长度

{

if(CheckKeyword(temp)==1)〃是关键字

if(op==l)0CreateHashList(HT,temp);〃22为1,表示

使用开放地址法

elseLCreateHashList(HL,temp);〃否则是链地址法

memset(temp'\0',sizeof(temp))"/清空字符数组

i=0;

}

}

c=fgetc(rf);//接收字符

if(!((c>64&&c<91)||(c>96&&c<123)))

{〃读到不是字母，则字符数组清空

memset(temp,'\0',sizeof(temp));i=0;

)

if(c=='/，)〃去除性释

{〃读取下一个字符，如果是/说明是行注释，如果是*则是块注释

t=fgetc(rf);

if(t==7-〃如果是/

{

t=fgetc(rf);〃读取字符

while(t!=10)〃除非读到换行符，否则继续循环

t=fgetc(rf);

}

elseif(t=='*')〃如果是*

{

t=fgetc(rf);

while(t!=，*，)〃除非读到*字符，否则继续循环

t=fgetc(rf);

t=干868(讦)；〃接收'/'字符

}

}

)

}

不难发现，上面这一段程序中，存在这一个很大的不足，函数一开始位

置和while循环位置的接收字符语句后都有排除注释的操作，重复的代码使

得这一模块显得很臃肿，而且，其中还有一个漏洞：在判断块注释结尾时，

只判断是否出现"*"字符是行不通的，因为注释中可能有指针声明或定义，如

(int*a;)o因此，为使该模块显得更简洁并纠正其中的错误，我做了如下更

改：

1.字符接收语句只在函数开始位置，while循环中不添加字符接收语句。

2.使用while循环控制块注释结尾的判断，一旦接收到"*"字符，就判断

下一个字符是否是〃/，，字符

修改代码如下：

while())

­

c=fgetc(rf);if(c<0)break;

if(c=='/')〃去除注释

{〃读取下一个字符，如果是/说明是行注释，如果是*则是块注释

c=fgetc(rf);

if(c=='/，)〃如果是/

{

while(c!=10)〃除非读到换行符，否则继续循环

c=fgetc(rf);

)

elseif(c=='*')〃如果是*

{

while(l)

{

if(c=='*')

{

c=fgetc(rf);if(c=='/')break;

}

c=fgetc(rf);

}

)

}

if((c>64&&c<91)||(c>96&&c<123))〃关键字由字母组成

(

temp[i++]=c;〃临时存储字符

if(strlen(temp)<=KEYMAXLEN)〃如果当前字符串长度小于等于关键字

最大长度

{

if((：110d<1<6丫00「6|(1：611^)==：1)〃是关键字一

{

if(op==l)0CreateHashList(HT,teinp);〃2£ZH，表示使川开

放地址法

elseLCreateHashList(HL,temp);〃否则是链地址法

memset(temp,'\0',sizeof(temp，S；〃清空字符数组

i=0;

}

)

}

if(!((c>64&&c<91)||(c>96&&c<123)))

{〃读到不是字母，则字符数组清空

memset(temp,'\0',sizeof(temp));i=0;

}

}

修改之后，模块代码显得更简洁，易于理解。

4.3算法时空分析

4.3.1SortKeyO复杂度

由于函数中采用的方法为冒泡排序算法，因此时间复杂度为：0(M2),

空间复杂度为S(M2)。模块代码如下：

voidSortKey(keykeys[])

(

intijjjn=0;keytemp;

while(strlen(keys[n].keyword)!=0)n++;

for(i=0;i<n-l;i++)

{

for(j=0;j<n-l-i;j++)

(

if(strcmp(keys[j].keyword,keys[j+1],keyword)>0)

temp=keys[j];keys[j]=keys[j+1];keys[j+l]=temp;

)

)

)

}

4.3.2OFind()函数复杂度

由于函数中有for循环，且层数最多为1,因此模块时间复杂度为0(n),

空间复杂度为S(n)。模块代码如下：

〃寻找关键字存放位置

intOFind(HashTable&HT,char*keywordJintkey)

{

inti.flag;

for(i=0;i<HASHLEN;i++)//由于可能仃多种情况，所以必须全部比较一次

if(strcmp(HT[i].keyword,keyword)==0)returni;〃如果找到相同关键

字则返回位置

for(i=key;i<HASHLEN;i++)//未找到则向后搜索空位

if(strlen(HT[i].keyword)==0)returni;〃返回空位的位置

for(i=0;i<key;i++)//向后搜索未找到空位则从头开始搜索

if(strlen(HT[i].keyword)==0)returni;//返回空位的位置

}

4.3.3CheckKeyword()函数复杂度

检查关键字模块中采用的方法是折半查找法，因此，模块时间复杂度为

O(log(n)),空间复杂度为S(log(n))。模块代码如下：

intCheckKeyword(char*s)〃检查s"?：符数组是否为关键字

{

intiJbegin=0Jend=8;

while(begin<=end)〃折半查找法

{

i=(begin+end)/2;

if(strcmp(keywords[i],s)==0)return1;〃找到返回1

elseif(strcmp(keywords[i],s)>0)end=i-l;

elseif(strcmp(keywords[i],s)<0)begin=i+l;

)

return0;〃未找到返回0

}

4.4程序设计回顾

第一步，从程序文件中读取并存储关键字。由于关键字是由字母组成的，因

此当遇到字母时，就需要临时把它存储起来，这里使用一个字符数组来接收它，

从而方便判断得到的字符串是否是关键字，如果遇到不为字母的字符，说明字母

串已结束，因此，此时应清空临时接收字符的数组。在接收字母的同时，应进行

关键字的核对，如果是关键字，则应存储该关键字，否则继续接收，一旦超过了

关键字最大长度，就应清空临时接收字符数组。同时，应特别注意注释的问题，

由于注释中可能存在关键字，所以需要过滤注释，具体方法为：如果接收到

字符，则使用一个字符变量接收下一个字符，如果是说明是行注释，接下

来则使用该变量不断接收字符，直到接收到换行符为止，如果该字符变量接收

至1*"字符，说明是块注释，接下来则使用该变量不断接收字符，直到接收到"*"

字符为止。

第二步，写入得到的关键字信息。依次将关键字信息写入到指定的文件中，

根据使用方法的不同，写入的操作会不相同，具体可参考附录：源代码。

第三步，计算相对距离S。由于散列表中可能存在一些位置中没有关键字存

储的情况，因此，需要过滤没有存储关键字的位置，可以另外定义一个关键字结

构体数组，来存储真正有效的关键字。存储完成后，应进行排序，可按从小到大

的顺序进行排序，便于计算其构成向量的差值，最后根据所给公式计算出相对距

离S即可。

第四步，统计执行时间。在用户选择某种方法后，就应使用一个变量记录此

时的时间，可以调用clock。函数记录当前时间，调用该函数需要添加头文件

time.ho在程序执行完该方法的所需步骤后，记录下此时的时间，二者相减即可

得到该方法执行时间。

4.5经验和体会

相比于第一次的课程设计，这次较简单些，散列表的知识比较浅显易懂，因

此，在上次课程设计后不久，我就把这题的代码写出来了，虽然后来修改了很多

次，但是这次是靠自己写出来的，没像第一次课程设计那样，得依赖资料才能勉

勉强强写出来。应该是因为自己的水平还不足吧，对于调试中的一些问题，自己

还是没能解决，在帮室友调试这道题的程序时，用C-Free遇到一个段错误（图

4.5-1），但是程序放在VisualC++里编译运行却没有问题（图4.5-2）。

图4.5-1段错误

图4.5-2VC++下程序运行没有问题

虽然现在还没能找到原因，但是我会努力调试，找出其中的问题，以后也有

可能会面对这样的程序，我相信，通过不断地调试，一定能找到问题的所在。

这次的课程设计，我收获了许多，对于程序的编写、改进和调试能力有了一

些进步，但这些是远远不够的，唯有通过不断地练习、做题，才能真正提高自己

的编程能力。所以，在即将到来的寒假，我将利用一些时间去做题，努力强化自

己，争取在编程之路上走得更远!

加油!!!

5测试结果

5.1简单程序测试

（vc++编译，有内联汇编部分代码）

5.1.1测试文件内容

程序1文件名：l.cpp

程序1文件路径：f：\

程序1文件内容：图5.1；

-Icpp2CPP

V**C++SourceFile忙:C++SourceFile

I~I104字方I---I83字花

图5.1-1程序1和程序2文件信息

程序2文件名：2.cpp

程序2文件路径：f:\

程序2文件内容：图5.1-1

5.1.2程序输入界面

图5.1-2程序输入界面

5.1.3测试运行结果

5.1.3.1开放地址法测试结果

图5.1-3识别并统计关键字频度结果

睛

题

井

L识

翁

计

2.址

别r

3.主

界

放

4请.

需

识

开

行

间

瞿

:3址

天

洋

并

字

1.回

离

相S

2.时

返

执

可

行

3.地

择

界面

4.请

遗

王

■：

图5.1-5开放地址法执行时间结果

5.1.3.2链地址法测试结果

图5.1-6识别并统计关键字频度结果

图5.1-7计算相对距离S结果

1•G:\13\Debug\13.exe.

一

关

频

计

字

统

键

度

谢

离S

计

时

间

行

号

选

放

执

行

识

计

关

计

距

高

链

执

行

返

主