文学助手研究 数据结构 测试五Word下载.docx
《文学助手研究 数据结构 测试五Word下载.docx》由会员分享，可在线阅读，更多相关《文学助手研究 数据结构 测试五Word下载.docx（22页珍藏版）》请在冰豆网上搜索。
//有序表尾指针
//有序表结点个数
}OrderList;
/*---记录一行中匹配成功单词在目标词汇表中的位置---*/
inteqelem[MAXNUM];
//单词在目标词汇表中的位置
intlast;
//匹配成功单词的个数
}EqelemList;
/*-----------文件测试相关的数据类型定义-----------*/
/*--------------单词在文件中的位置----------------*/
typedefstructNode{
intelem;
//被测单词在文件中的行号
structNode*next;
//指向下一个行号结点的指针
}Node,*Link;
/*-----------单词统计分析记录结构定义-------------*/
WordTypedata;
//被测试的单词
intcount;
//在文件中出现的次数
Linknext;
//记录出现的所有行号的脸表头指针
}HeadNode;
/*---------文本文件测试结果记录定义---------------*/
typedefHeadNodeResultType[MAXNUM];
typedefintstatus;
/*------------与单词相关的函数----------------*/
/*--------------------------------------------*/
/*定义新单词函数*/
/*功能：
把新单词放入堆中*/
/*参数：
WordType*nw--单词描述信息指针*/
/*Sequencecha--单词信息*/
/*返回值：
操作成功与否的状态信息*/
/*0--操作失败，空间不足；
1--操作成功*/
statusNewWord（WordType*nw,Sequencecha）
{inti,k;
if（sp.freep+cha.size>
=MAXSIZE）
{printf（"
HeapFull!
\n"
）;
getchar（）;
return（0）;
}
else{
i=sp.freep;
sp.freep=sp.freep+cha.size;
for（k=0;
k<
cha.size;
k++）
sp.stores[i+k]=cha.ch[k];
nw->
stadr=i;
len=cha.size;
return
（1）;
/*复制单词信息函数*/
把一个单词信息复制到另一个变量中*/
WordType*nw--新单词描述信息指针*/
/*WordTypeoldw--旧单词描述信息指针*/
无*/
voidCopyWord（WordType*nw,WordTypeoldw）
{nw->
stadr=oldw.stadr;
len=oldw.len;
/*单词比较函数*/
比较堆中两单词的大小*/
WordTypewd1--第一个单词描述信息*/
/*WordTypewd2--第二个单词描述信息*/
-1--小于；
0--等于；
1--大于*/
intWordCmp（WordTypewd1,WordTypewd2）
{intsi,sj;
for（si=wd1.stadr,sj=wd2.stadr;
si<
（wd1.stadr+wd1.len）&
&
sj<
（wd2.stadr+wd2.len）;
si++,sj++）
{
if（sp.stores[si]>
sp.stores[sj]）
return
（1）;
elseif（sp.stores[si]<
return（-1）;
if（wd1.len>
wd2.len）/*两个单词长度不相等*/
elseif（wd1.len<
wd2.len）
else
return（0）;
/*打印单词函数*/
打印堆中一个单词*/
WordTypewd--单词描述信息*/
voidPrintWord（WordTypewd）
{inti;
for（i=0;
i<
wd.len;
i++）
putchar（sp.stores[wd.stadr+i]）;
/*---------------与有序表相关的函数-----------*/
/*结点生成函数*/
生成一个单词在堆中存储信息的结点*/
LinkType*p--生成的新结点指针*/
/*ElemTypee--单词存储信息*/
TRUE--成功；
FALSE--失败*/
statusMakeNode（LinkType*p,ElemTypee）
{*p=（LinkType）malloc（sizeof（NodeType））;
if（!
（*p））return（FALSE）;
（*p）->
data.stadr=e.stadr;
data.len=e.len;
next=NULL;
return（TRUE）;
/*有序表初始化函数*/
申请头结点，初始化有序表*/
OrderList*L--有序表指针*/
TRUE--初始化成功；
FALSE--初始化失败*/
statusInitList（OrderList*L）
{ElemTypewd;
wd.stadr=-1;
wd.len=0;
if（MakeNode（&
（L->
head）,wd））
{L->
tail=L->
head;
L->
head->
size=0;
else{L->
head=NULL;
return（FALSE）;
}
/*撤销有序表函数*/
释放有序表所有结点，撤销有序表*/
voidDestroyList（OrderList*L）
{LinkTypep,q;
if（L->
size==0）
return;
p=L->
while（p）{
q=p;
p=p->
next;
free（q）;
head=L->
tail=NULL;
/*有序表查找函数*/
确定给定单词e在有序表中的位置*/
OrderListL--有序表*/
/*ElemTypee--给定要查找的数据e*/
/*LinkType*q--有序表结点指针*/
/*查找成功，q指向具有e值的结点*/
/*查找失败，q指向小于e的结点*/
int型，1--查找成功；
0--查找失败*/
statusLocateElem（OrderListL,ElemTypee,LinkType*q）
{LinkTypepre,p;
intt;
pre=L.head;
p=L.head->
while（p）
{
t=WordCmp（p->
data,e）;
if（t==0）
*q=p;
elseif（t==-1）
pre=p;
else
*q=pre;
*q=pre;
return（0）;
/*有序表插入函数*/
在指定结点q后插入一个结点s*/
/*LinkTypeq--指定结点指针*/
/*LinkTypes--待查入结点指针*/
voidInsertAfter（OrderList*L,LinkTypeq,LinkTypes）
{if（L->
head&
q&
s）{
s->
next=q->
q->
next=s;
tail==q）L->
tail=s;
size++;
/*------------------------------------------------*/
/*表匹配函数*/
把Lb表中匹配La表成功的元素放入s表*/
OrderListLa--存放统计单词的有序表*/
/*OrderListLb--存放待匹配单词的有序表*/
/*EqelemList*s--存放匹配成功单词信息表指针*/
voidListCompare（OrderListLa,OrderListLb,EqelemList*s）
{intpos;
LinkTypepa,pb;
if（La.head&
Lb.head）{
pb=Lb.head->
last=0;
pos=0;
for（pa=La.head->
pa!
=NULL;
pa=pa->
next）
while（pb）
if（WordCmp（pa->
data,pb->
data）==0）
eqelem[s->
last++]=pos;
elseif（WordCmp（pa->
data）==-1）
break;
pb=pb->
}//while
pos++;
pb=Lb.head->
}//for
}//if
/*判表空函数*/
判断表L是否是空表*/
0--非空表；
1--空表*/
statusListEmpty（OrderListL）
{if（L.size==0）return（TRUE）;
return（FALSE）;
/*-----------与文本文件有关的函数-------------*/
/*字符判断函数*/
判断文件中下一个字符是否为回车符*/
FILE*f--文件指针*/
0--不是回车符；
1--是回车符*/
intfeoln（FILE*f）
{charcha;
cha=fgetc（f）;
ungetc（cha,f）;
if（cha=='
\n'
）return（TRUE）;
/*读取单词函数*/
从文件中读取一个单词*/
/*Sequence*st--指向单词的指针*/
voidGetAWord（FILE*f,Sequence*st）
{charch;
st->
printf（"
getaword\n"
do{
ch=fgetc（f）;
}while（ch=='
'
//do......while
if（ch=='
）
while（ch!
='
ch[st->
size]=ch;
ch=fgetc（f）;
||ch==-1）
ungetc（ch,f）;
return;
/*读取文件当前行单词函数*/
提取文件指针所在行所有单词*/
/*OrderList*ta--存放单词有序表的指针*/
0--操作失败；
statusExtractWord（FILE*f,OrderList*ta）
{
Sequencestr;
WordTypenwd;
LinkTypep;
LinkTypes;
Extractword\n"
if（InitList（ta）==0）
InitListtahaveerrors!
!
while（!
feof（f）&
feoln（f））/*文件结束或行结束*/
GetAWord（f,&
str）;
if（str.size==0）
if（NewWord（&
nwd,str）==0）
printf（"
NewWorderrors!
p,nwd）==0）
MakeNodeerrors!
LocateElem（*ta,nwd,&
s）;
InsertAfter（ta,s,p）;
}//while
fgetc（f）;
return
（1）;
/*文件单词匹配函数*/
统计指定单词在文件中出现的次数和位置*/
/*OrderListpat--指定统计的单词有序表*/
/*ResultTypers--统计结果列表*/
0--统计失败；
1--统计成功*/
statusmatch（FILE*f,OrderListpat,ResultTypers）
inti,k,linenum,failed,fsp;
OrderListsa;
EqelemListeqlist;
Linkq;
linenum=1;
feof（f））
if（InitList（&
sa）==0）
InitList（sa）errors!
eqlist.last=0;
ExtractWord（f,&
sa））
ExtractWorderrors!
return0;
ListCompare（pat,sa,&
eqlist）;
DestroyList（&
sa）;
if（eqlist.last!
=0）
eqlist.last;
failed=1;
fsp=eqlist.eqelem[i];
rs[fsp].count++;
for（k=0;
i;
if（eqlist.eqelem[i]==eqlist.eqelem[k]）
{failed=0;
if（failed==1）
q=（Link）malloc（sizeof（Node））;
elem=linenum;
next=rs[fsp].next;
rs[fsp].next=q;
}//if语句
}//for语句
}//if语句
linenum++;
}//while语句
/*初始化文件函数*/
输入指定的文件名并打开文件*/
FILE**f--返回的文件指针*/
0--初始化失败；
1--初始化成功*/
statusInitialization（FILE**fr）
{charFileName[30];
Inputfilename:
"
do{scanf（"
%s"
FileName）;
}while（strlen（FileName）==0）;
*fr=fopen（FileName,"
r"
if（*fr）
fileopen!
else{printf（"
filenotopen!
/*输入统计的词集函数*/
输入待统计的词集并建立起数据结构*/
OrderList*pt--返回的词集有序表指针*/
voidInputWord（OrderList*pt）
{charcc;
intt=0;
Sequencews;
LinkTypep,q;
InitList（pt））
升级会员 