《C语言程序设计实验》实验报告样板Word文档下载推荐.docx
《《C语言程序设计实验》实验报告样板Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《《C语言程序设计实验》实验报告样板Word文档下载推荐.docx(15页珍藏版)》请在冰豆网上搜索。
![《C语言程序设计实验》实验报告样板Word文档下载推荐.docx](https://file1.bdocx.com/fileroot1/2022-12/30/5a05bdb7-b2f1-42a6-8891-767716a7064d/5a05bdb7-b2f1-42a6-8891-767716a7064d1.gif)
aeort'
,Setl-Set2='
Inp'
;
二、概要设计
为实现上述程序功能,应以有序链表表示集合。
为此,需要两个抽象数据类型:
有序表和集合。
(1)有序表的抽象数据类型定义为:
ADTOrderedList{
数据对象;
D={ai|ai∈CharSet,i=1,2,…,n,n≥0}
数据关系:
R1={<ai-1,ai>|ai-1,ai∈D,ai-1<ai,i=1,2,…,n,}
基本操作:
InitList(&
i)
操作结果;
构造=个空的有序表L。
DestroyList(&
L)
初始条件:
有序表L已存在。
操作结果:
销毁有序表L。
ListLength(L)
返回有序表L的长度。
ListEmpty(L)
若有序表L为空表,则返回True,否则返回False。
GetElem(L,pos)
若l≤pos≤Length(),则返回表中第pos个数据元素。
LocateElem(L,e,&
q)
若有序表L中存在元素e,则q指示L中第一个值为e的元素的位置,并返回函数值TRUE;
否则e指示第一个大于e的元素的前驱的位置,并返回函数值FALSE。
APPend(&
L,e)
在有序表L的末尾插入元素e。
InsertAfter(&
L,q,e)
有序表L已存在,q指示L中一个元素。
在有序表L中q指示的元素之后插入元素e。
ListTraverse(q,visit())
依次对L中q指示的元素开始的每个元素调用过程visit()。
}ADTOrderedList
(2)集合的抽象数据类型定义为:
ADTSet{
数据对象:
①=(ai|ai为小写英文字母且互不相同,i=1,2,…,n,0≤n≤26)
R1={}
Createset(&
T,Str)
Str为字符串。
生成一个由*中小写字母构成的集合T。
Destroyset(&
T)
集合T已存在。
销毁集合T的结构。
Union(t,S1,S2)
集合S1和S2存在。
生成一个由S1和S2的并集构成的集合T。
Intersection(&
T,S1,S2)
生成一个由a和S2的交集构成的集合T。
Difference(&
生成一个由S1和S2的差集构成的集合T。
Printset(T)
按字母次序顺序显示集合T的全部元素。
}ADTSet
(3)本程序包含4个模块:
1)主程序模块:
BEGIN{main}
初始化;
REPEAT
接受命令;
处理命令;
UNTIL“命令”=“退出”;
END.
2)集合单元模块——实现集合的抽象数据类型;
3)有序表单元模块——实现有序表的抽象数据类型;
4)结点结构单元模块——定义有序表的结点结构.各模块之间的调用关系如下:
三、详细设计
(1)元素类型、结点类型和指针类型
TYPEElemType—char;
{元素类型}
LinkType=^NodeType;
{指针类型}
NodeType—RECORD{结点类型}
data:
ElemType;
next:
LlnkType
END;
ViSitProc—PROCEDURE(p:
LinkType);
{访问结点的过程类型}
FUNCMakeNode(VARp:
LinkType;
e:
ElemType):
boolean;
{分配由p指向的数据元素为e、后继为“空”的结点,并返回“True”,}
{若分配失败,则返回“False”}
IFMaxAvail<Sizeof(p^)THENreturn(False)
{MaxAvail是标准无参函数,返回堆中最大自由块的大小}
ELSE【new(p);
p^.data:
=e;
p.next:
=NIL;
return(True)】
ENDF;
PROCFreeNode(VARp:
{释放P所指结点}
FUNCCopy(p:
LinkType):
{复制生成和指针P所指结点有同值元素的新结点并返回,若分配空间}
{失败,则返回空指针。
新结点的指针域为NIL}
IFMaxAvailSizeof(p^)THENreturn(NIL)
{MaxAvail是标准无参函数,返回堆中最大自由块的大小}
ELSE【new(s);
s.data:
=p”.data;
s^.next:
return(s)】
ENDF;
FUNCElem(p:
{若指针P<NIL,则返回P所指结点的数据元素,否则返回’#’}
FUNCSuccNode(p:
{若指针P<>NIL,则返回指向P所指结点的后继元素的指针。
}
{否则返回NIL}
(2)根据有序表的基本操作的特点,有序表采用有序链表实现。
链表设头、尾两个指针和表长数据域,并附设头结点,头结点的数据域没有实在意义。
TYPEOrderedList—RECORD{有序链表类型}
head,tail:
LinkType;
{分别指向线性链表的头结点和尾结点}
Size:
integer;
{指示链表当前的长度}
有序链表的基本操作设置如下:
FUNCInitList(VARL:
OrderedList):
{构造一个带头结点的空的有序链表L,并返回“true”;
}
{若分配空间失败则令L.head为NIL,并返回“False”}
PROCDestroyList(VARL:
OrderedList);
{销毁有序链表L}
FUNCListEmpty(L:
boollean;
{若L不存在或为“空表”,则返回“True”,否则返回“False”}
FUNCListLength(L:
Integer;
{返回链表的长度}
FUNCGetElemPos(L:
OrderedList;
Pos:
integer):
{若L存在且O<Pos<L.Size+1,则返回指向第pos个元素的指针,}
{否则返回NIL}
FUNCLOCateElem(L:
e:
ElemType;
VARq:
boolean;
{若有序链表L存在且表中存在元素e,则q指示L中第一个值为e的结点的位置,并返回True;
否则q指示第一个大于e的元素的前驱的位置,并返回False}
PROCAppend(VARL:
s:
{在已存在的有序链表L的末尾插入指针S所指结点}
PROCInsertAfter(VARL:
OrderList;
q:
linkType);
{在已存在的有序链表L中q所指示的结点之后插入指针S所指结点}
PROCTraverseList(p:
viS1t:
Proc);
{从p(p<>NIL)指示的结点开始,依次对每个结点调用过程Visit()}
其中部分操作的伪码算法如下:
boolean;
IFMakeNode(head,'
'
)THEN{头结点的虚设元素为空格符'
【L.tail:
=L.head;
L.Size:
=0;
return(True)
】
ELSE【
L.head:
=NIL;
return(False)
ENDP;
{InitList}
WITHLDO
【p:
=head;
WHILEp<>NILDO
【q:
=PP:
=SuCCNode(P);
FreeNode(q)】;
head:
=tail:
=NIL
{DestroyList}
pos:
integer)):
IF(L.head=NIL)OR(pos<1)OR(pos>L.Size)THENreturn(NIL)
ELSEIFpos=L.SizeTHENreturn(L.tail)
p:
=L.head^.next;
k:
=1;
WHILE(p<>NIL)CAND(k<Pos)DO
=SuccNode(p);
=k+1;
】
return(P)
{GetElemPos}
FUNCLocateElem(L:
OrderedList;
VARp:
IFL.head<>NILTHEN【
pre:
=L.head;
p:
=pre.next;
{pre指向p^的前驱,P指向第一个元素结点}
WHILE(p<>NIL)CAND(p^.data<e)DO
【Pre:
=SuccNode(p)】;
IF(p<>NIL)CAND(p^.data=e)THENreturn(True)
ELSE【p:
=pre;
return(False)】
ELSEreturn(False)
{LocateElem}
IF(L.head<>NIL)CAND(s<>NIL)THEN【
IFtail<>headTHEN【tail^.next:
=s;
tail:
=s】
ELSE【head^.next:
=s】;
Inc(L.Size)】
{Append}
OrderListt;
IF(L.head<>NIL)AND(q<>NIL)CAND(s<>NIL)THEN
【s.next:
=q^.next;
q^.next:
IFL.tail=qTHENL.tail:
=s;
Inc(L.Size)
{InsertAfter}
PROCListTraverse(p:
LinkTypeviS1t:
【visit(p);
=SuccNOde(p)】
{ListTraverse}
(3)集合Set利用有序链表类型OrderedLList来实现,定义为有序集Orderedset:
TYPEOrderedset—OrderedList;
集合类型的基本操作的类Pascal伪码描述如下:
PROCCreateset(VART:
Orderedset;
s:
string);
{生成由串s中小写字母构成的集合T,IsLower是小写字母判别函数}
IFInitList(T){构造空集T}THEN
FORi:
=1TOlength(s)DO
IFIsLower(s[i])CANDNOTLocateElem(T,s[i],p)THEN
{过滤重复元素并按字母次序大小插入}
IFMakeNode(q,s[i])THEN
InsertAfter(T,p,q)
ENDP;
{Createset}
PROCDestroyset(VART:
Orderedset);
{销毁集合T的结构}
DestroyList(T)
PROCUnion(VART:
Orderedset;
S1,S2:
{求已建成的集合S1和S2的并集T,即S1.head<>NIL且S2.head<>NIL}
IFInitList(T)THEN【
pl:
=GetElemPos(s1,1);
p2:
=GetElemPos(S2,1);
WHILE(pl<>NIL)AND(p2<>NIL)DO
【c1:
=Elem(pl);
c2=Elem(p2);
IFC1<=C2THEN
【Append(T,Copy(pl));
pl:
=SuCCNOde(pl);
IFC1=c2THENp2:
=SUCCNOde(p2);
】
ELSE【Append(T,Copy(p2));
=SuccNode(p2);
WHILEpl<>NILDO
=SuccNode(pl);
】;
WHILEp2<>NILDO
【Append(T,Copy(p2));
{Union}
PROCEDUREIntersection(VART:
{求集合S1和S2的交集T}
IFNOTInitList(T)THENT.head=NIL
ELSE【
=GetElemPOs(S1,1);
c2:
=Elem(p2);
IFC1<C2THENpl:
=SuccNode(pl)
ELSEIFC1>C2THENp2:
=SuccNode(p2)
ELSE{c1=c2}
p2:
=SuccNOde(p2)】
{Intersection}
PROCDifference(VART:
S1,S2:
{求集合S1和S2的差集T}
IFNOTInitList(T)THENT.head:
=GetElemPos(S1,1);
WHILE(p1<>NIL)AND(p2<>NIL)DO
=Elem(p1);
IFc1<c2THEN
=SuccNode(pl)】
ELSE{c1=C2}
【pl:
=SuccNode(p2)】
】;
WHILEp1<>NILDO
=SuccNode(pl)】
{Difference}
PROCWritesetElem(p:
LlnkType);
{显示集合的一个元素}
write('
,'
);
WriteElem(Elem(p));
{WritesetElem}
PROCPrintset(T:
{按Pascal格式显示集合的全部元素}
=GetElemPos(T,1);
['
IFp<>NILTHEN
【writeSetElem(p);
=SuccNode(p)】
ListTraverse(p,WrltesetElem);
wrietelnn('
]'
{Printset}
(4)主程序和其他过程的伪码算法
BEGIN{主程序}
Initialization;
(初始化)
REPEAT
ReadCommand(cmd);
{读入一个操作命令符}
InterPret(cmd){解释执行操作命令符}
UNTILcmdIN['
q'
'
Q'
]
END.{main}
PROCInitialization;
{系统初始化}
Clrscr;
{清屏}
在屏幕上方显示操作命令清单:
Makesetl--1
Makeset2--2
Union--u
Intersaction--i
Difference--d
Quit--q;
在屏幕下方显示操作命令提示框;
Createset(Setl,'
Printset(Setl);
{构造并显示空集Setl}
Createset(Set2,'
Printset(Setl)
{构造并显示空集Set2}
{Initializatlon}
PROCReadCommand(VARcmd:
char);
{读入操作命令符}
显示键入操作命令符的提示信息;
cmd:
=ReadKey
1'
2'
u'
U'
i'
I'
d'
D'
];
回显cmd
PROCInterpret(cmd:
Char);
{解释执行操作命令cmd}
CASEcmdOF
'
:
【显示以串的形式键人集合元素的提示信息;
readh(v);
{读入集合元素到串变量v}
Createset(Setl,v);
{构造并显示有序集Setl}
【显示以串的形式键入集合元素的提示信息;
rcaredln(v);
{读入集合元素到串变量v}
Createset(Set2,v);
Printset(Set2);
{构造并显示有序集Set2}
【Union(Set3,Setl,Set2);
{求有序集Setl和Set2的并集Set3}
Printset(Set3);
{显示并集Set3}
DestroyList(Set3){销毁并集Set3}
【Intersaction(Set3,Setl,Set2);
{求有序集Setl和Set2的交集Set3}
DestroyList(Set3)
d‘,'
【Difference(Set3,Setl,Set2);
{求集合Setl和Set2的差集Set3}
ENDC;
(Interpret)
(5)过程和函数的调用关系图反映了演示程序的层次结构:
四、调试分析
(1)由于对集合的3种运算的算法推敲不足,在有序链表类型的早期版本未设置尾指针和APPend操作,导致算法低效。
(2)初时曾忽略了一些变量参数的标识“VAR”,使调试程序时费时不少。
今后应重视确定参数的变量和赋值属性的区分和标识。
(3)本程序的模块划分比较合理,且尽可能将指针的操作封装在结点和链表的两个模块中,致使集合模块的调试比较顺利。
反之,如此划分的模块并非完全合理,因为在实现集合操作的编码中仍然需要判别指针是否为空,按理,两个链表的并、交和差的操作也应封装在链表的模块中,而在集合的模块中,只要进行相应的应用即可。
(4)算法的时空分析
1)由于有序表采用带头结点的有序单链表,并增设尾指针和表的长度两个标识,各种操作的算法时间复杂度比较合理。
InitList、ListEmpty、Listlength、Append和InsertAfter以及确定链表中第一个结点和之后一个结点的位置都是O
(1)的,DestroyList、LocateElem和TraverseList及确定链表中间结点的位置等则是O(n)的,n为链表长度。
2)基于有序链表实现的有序集的各种运算和操作的时间复杂度分析如下:
构造有序集算法Createset读入n个元素,逐个用LocateElem判定不在当前集合中及确定插入位置后,才用InsertAfter插入到有序集中,所以时间复杂度是O(n)。
求并集算法Union利用集合的“有序性”将两个集合的m+n个元素不重复地依次利用Append插入到当前并集的末尾,故可在O(m+n)时间内完成。
可对求交集算法Intersection和求差集算法Difference作类似地分析,它们也是O(m+n)的。
销毁集合算法Destroyset和显示集合算法Printset都是对每个元素调用一个O
(1)的过程,因此都是O(n)的。
除了构造有序集算法Createset用一个串变量读入n个元素,需要O(n)的辅助空间外,其余算法使用的辅助空间与元素个数无关,即是O
(1)的。
(5)本实习作业采用数据抽象的程序设计方法,将程序划分为四个层次结构:
元素结点、有序链表、有序集和主控模块,使得设计时思路清晰,实现时调试顺利,各模块具有较好的可重用性,确实得到了一次良好的程序设计训练。
五、用户手册
(1)本程序的运行环境为DOS操作系统,执行文件为:
SetDemos.exe。
(2)进