文学助手研究 数据结构 测试五.docx

文学助手研究 数据结构 测试五.docx

《文学助手研究 数据结构 测试五.docx》由会员分享，可在线阅读，更多相关《文学助手研究 数据结构 测试五.docx（22页珍藏版）》请在冰豆网上搜索。

文学助手研究数据结构测试五

#include

#include

#include

#include

#include

#defineMAXSIZE1000

#defineMAXLEN20

#defineMAXNUM16

#defineFALSE0

#defineTRUE1

/*---------------堆结构的定义---------------*/

typedefstruct{

charstores[MAXSIZE];

intfreep;//当前可用空间开始位置

}HeapSpace;

HeapSpacesp;

/*-------------单词数据类型定义-------------*/

/*-----------单词在堆中的位置描述-----------*/

typedefstruct{

intstadr;//单词在对空间中的开始位置

intlen;//单词长度

}WordType;

/*----------------单词描述-------------------*/

typedefstruct{

charch[MAXLEN];//单词字符串

intsize;//单词长度

}Sequence;

/*---------------有序表类型定义---------------*/

/*-------------单词有序表结点定义-------------*/

typedefWordTypeElemType;

typedefstructNodeType{

ElemTypedata;

structNodeType*next;

}NodeType,*LinkType;

/*----------------单词有序表定义--------------*/

typedefstruct{

LinkTypehead;//有序表头指针

LinkTypetail;//有序表尾指针

intsize;//有序表结点个数

}OrderList;

/*---记录一行中匹配成功单词在目标词汇表中的位置---*/

typedefstruct{

inteqelem[MAXNUM];//单词在目标词汇表中的位置

intlast;//匹配成功单词的个数

}EqelemList;

/*-----------文件测试相关的数据类型定义-----------*/

/*--------------单词在文件中的位置----------------*/

typedefstructNode{

intelem;//被测单词在文件中的行号

structNode*next;//指向下一个行号结点的指针

}Node,*Link;

/*-----------单词统计分析记录结构定义-------------*/

typedefstruct{

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

sp.stores[i+k]=cha.ch[k];

nw->stadr=i;

nw->len=cha.size;

return

（1）;

}

}

/*--------------------------------------------*/

/*复制单词信息函数*/

/*功能：

把一个单词信息复制到另一个变量中*/

/*参数：

WordType*nw--新单词描述信息指针*/

/*WordTypeoldw--旧单词描述信息指针*/

/*返回值：

无*/

/*--------------------------------------------*/

voidCopyWord（WordType*nw,WordTypeoldw）

{nw->stadr=oldw.stadr;

nw->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）/*两个单词长度不相等*/

return

（1）;

elseif（wd1.len

return（-1）;

else

return（0）;

}

/*--------------------------------------------*/

/*打印单词函数*/

/*功能：

打印堆中一个单词*/

/*参数：

WordTypewd--单词描述信息*/

/*返回值：

无*/

/*--------------------------------------------*/

voidPrintWord（WordTypewd）

{inti;

for（i=0;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;

（*p）->data.len=e.len;

（*p）->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->next=NULL;

L->size=0;

return（TRUE）;

}

else{L->head=NULL;

return（FALSE）;

}

}

/*--------------------------------------------*/

/*撤销有序表函数*/

/*功能：

释放有序表所有结点，撤销有序表*/

/*参数：

OrderList*L--有序表指针*/

/*返回值：

无*/

/*--------------------------------------------*/

voidDestroyList（OrderList*L）

{LinkTypep,q;

if（L->size==0）

return;

p=L->head;

while（p）{

q=p;p=p->next;

free（q）;

}

L->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->next;

while（p）

{

t=WordCmp（p->data,e）;

if（t==0）

{

*q=p;

return

（1）;

}

elseif（t==-1）

{

pre=p;

p=p->next;

}

else

{

*q=pre;

return（0）;

}

}

*q=pre;

return（0）;

}

/*--------------------------------------------*/

/*有序表插入函数*/

/*功能：

在指定结点q后插入一个结点s*/

/*参数：

OrderList*L--有序表指针*/

/*LinkTypeq--指定结点指针*/

/*LinkTypes--待查入结点指针*/

/*返回值：

无*/

/*--------------------------------------------*/

voidInsertAfter（OrderList*L,LinkTypeq,LinkTypes）

{if（L->head&&q&&s）{

s->next=q->next;q->next=s;

if（L->tail==q）L->tail=s;

L->size++;

}

}

/*------------------------------------------------*/

/*表匹配函数*/

/*功能：

把Lb表中匹配La表成功的元素放入s表*/

/*参数：

OrderListLa--存放统计单词的有序表*/

/*OrderListLb--存放待匹配单词的有序表*/

/*EqelemList*s--存放匹配成功单词信息表指针*/

/*返回值：

无*/

/*------------------------------------------------*/

voidListCompare（OrderListLa,OrderListLb,EqelemList*s）

{intpos;

LinkTypepa,pb;

if（La.head&&Lb.head）{

pb=Lb.head->next;

s->last=0;

pos=0;

for（pa=La.head->next;pa!

=NULL;pa=pa->next）

{

while（pb）

{

if（WordCmp（pa->data,pb->data）==0）

s->eqelem[s->last++]=pos;

elseif（WordCmp（pa->data,pb->data）==-1）

break;

pb=pb->next;

}//while

pos++;

pb=Lb.head->next;

}//for

}//if

}

/*--------------------------------------------*/

/*判表空函数*/

/*功能：

判断表L是否是空表*/

/*参数：

OrderListL--有序表*/

/*返回值：

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）;

return（FALSE）;

}

/*--------------------------------------------*/

/*读取单词函数*/

/*功能：

从文件中读取一个单词*/

/*参数：

FILE*f--文件指针*/

/*Sequence*st--指向单词的指针*/

/*返回值：

无*/

/*--------------------------------------------*/

voidGetAWord（FILE*f,Sequence*st）

{charch;

st->size=0;

printf（"getaword\n"）;

do{

ch=fgetc（f）;

}while（ch==''）;//do......while

if（ch=='\n'）

{

st->size=0;

return;

}//if

while（ch!

=''）

{

st->ch[st->size]=ch;

st->size++;

ch=fgetc（f）;

if（ch=='\n'||ch==-1）

{

ungetc（ch,f）;

return;

}

}

}

/*--------------------------------------------*/

/*读取文件当前行单词函数*/

/*功能：

提取文件指针所在行所有单词*/

/*参数：

FILE*f--文件指针*/

/*OrderList*ta--存放单词有序表的指针*/

/*返回值：

0--操作失败；1--操作成功*/

/*--------------------------------------------*/

statusExtractWord（FILE*f,OrderList*ta）

{

Sequencestr;

WordTypenwd;

LinkTypep;

LinkTypes;

printf（"Extractword\n"）;

if（InitList（ta）==0）

{

printf（"InitListtahaveerrors!

!

\n"）;

return（0）;

}//if

while（!

feof（f）&&!

feoln（f））/*文件结束或行结束*/

{

GetAWord（f,&str）;

if（str.size==0）

return

（1）;

if（NewWord（&nwd,str）==0）

{

printf（"NewWorderrors!

\n"）;

return（0）;

}

if（MakeNode（&p,nwd）==0）

{

printf（"MakeNodeerrors!

\n"）;

return（0）;

}

LocateElem（*ta,nwd,&s）;

InsertAfter（ta,s,p）;

}//while

fgetc（f）;

return

（1）;

}

/*--------------------------------------------*/

/*文件单词匹配函数*/

/*功能：

统计指定单词在文件中出现的次数和位置*/

/*参数：

FILE*f--文件指针*/

/*OrderListpat--指定统计的单词有序表*/

/*ResultTypers--统计结果列表*/

/*返回值：

0--统计失败；1--统计成功*/

/*--------------------------------------------*/

statusmatch（FILE*f,OrderListpat,ResultTypers）

{

inti,k,linenum,failed,fsp;

OrderListsa;

EqelemListeqlist;

Linkq;

linenum=1;

while（!

feof（f））

{

if（InitList（&sa）==0）

{

printf（"InitList（sa）errors!

\n"）;

return（0）;

}//if

eqlist.last=0;

if（!

ExtractWord（f,&sa））

{

printf（"ExtractWorderrors!

\n"）;

return0;

}//if

ListCompare（pat,sa,&eqlist）;

DestroyList（&sa）;

if（eqlist.last!

=0）

{

for（i=0;i

{

failed=1;

fsp=eqlist.eqelem[i];

rs[fsp].count++;

for（k=0;k

if（eqlist.eqelem[i]==eqlist.eqelem[k]）

{failed=0;break;}

if（failed==1）

{

q=（Link）malloc（sizeof（Node））;

q->elem=linenum;

q->next=rs[fsp].next;

rs[fsp].next=q;

}//if语句

}//for语句

}//if语句

linenum++;

}//while语句

return

（1）;

}

/*--------------------------------------------*/

/*初始化文件函数*/

/*功能：

输入指定的文件名并打开文件*/

/*参数：

FILE**f--返回的文件指针*/

/*返回值：

0--初始化失败；1--初始化成功*/

/*--------------------------------------------*/

statusInitialization（FILE**fr）

{charFileName[30];

printf（"Inputfilename:

"）;

do{scanf（"%s",FileName）;

}while（strlen（FileName）==0）;

*fr=fopen（FileName,"r"）;

if（*fr）

{printf（"fileopen!

\n"）;

return（TRUE）;

}

else{printf（"filenotopen!

\n"）;

return（FALSE）;

}

}

/*--------------------------------------------*/

/*输入统计的词集函数*/

/*功能：

输入待统计的词集并建立起数据结构*/

/*参数：

OrderList*pt--返回的词集有序表指针*/

/*返回值：

无*/

/*--------------------------------------------*/

voidInputWord（OrderList*pt）

{charcc;

intt=0;

Sequencews;

LinkTypep,q;

WordTypenwd;

if（!

InitList（pt））

{