数据结构课程的实验报告.docx
《数据结构课程的实验报告.docx》由会员分享，可在线阅读，更多相关《数据结构课程的实验报告.docx（60页珍藏版）》请在冰豆网上搜索。
数据结构课程的实验报告
实验报告
实验课程：
学生姓名：
学号：
专业班级：
2012年6月5日
计算机系数据结构实验报告
---
（1）线性表及其应用
学生姓名：
学号：
专业班级：
实验类型：
□验证□综合■设计□创新实验日期：
2012/3/18实验成绩：
一．实验目的
帮助学生掌握线性表的基本操作在顺序和链表这两种存储结构上的实现，尤以链表的操作和应用作为重点。
二．问题描述
1．构造一个空的线性表L；
2．在线性表L的第i个元素之前插入新的元素e；
3．在线性表L中删除第i个元素，并用e返回其值。
三．实验要求
1．分别利用顺序和链表存储结构实现线性表的存储，并设计出在不同的存储结构中线性表的基本操作算法。
2．在实验过程中，对相同的操作在不同的存储结构下的时间复杂度和空间复杂度进行分析。
四．算法分析
1．插入操作：
输入数据：
L=（）ListInsert（L,1,'k'）,
正确结果：
L=（k）
输入数据：
L=（EHIKMOP）ListInsert（L,9,'t'）,
正确结果：
returnERROR;L=（EHIKMOP）
输入数据：
L=（ABCEHKNPQTU）ListInsert（L,4,'u'）,
正确结果：
L=（ABCuEHKNPQTU）
2．删除操作：
输入数据：
L=（）ListDelete（L,1,e）
正确结果：
ERROR,L=（）
输入数据：
L=（DEFILMNORU）ListDelete_Sq（L,5,e）
正确结果：
L=（DEFIMNORU）,e='L'
输入数据：
L=（CD）ListDelete_Sq（L,1,e）
正确结果：
L=（D）,e='C'
3．如线性表有n个结点，对两种存储结构下插入和删除的时间复杂度进行分析。
五．实验内容和过程
顺序存储C程序：
#include
#include
typedefintelemtype;
typedefintstatus;
#defineERROR-1
#defineOK1
#defineOVERFLOW2008
#defineLIST_INIT_SIZE100
#defineLISTINCREMENT10
typedefstruct{
elemtype*elem;
intlength;
intlistsize;
}sqlist;
statusInitList_Sq（sqlist*L）{
//构造一个空的线性表L
elemtype*a=0;
a=（elemtype*）malloc（LIST_INIT_SIZE*sizeof（elemtype））;
L->elem=a;
if（!
（*L）.elem）returnOVERFLOW;
（*L）.listsize=LIST_INIT_SIZE;
（*L）.length=0;
returnOK;
}
statusList_Insert（sqlist*L,inti,elemtypee）{
//在第i个元素之前插入元素e
elemtype*p=0;elemtype*q=0;elemtype*newbase=0;
if（i<1||i>（*L）.length+1）returnERROR;
if（（*L）.length>=（*L）.listsize）{
newbase=（elemtype*）realloc（（*L）.elem,（（*L）.listsize+LISTINCREMENT）*sizeof（elemtype））;
if（!
newbase）return（OVERFLOW）;
（*L）.elem=newbase;
（*L）.listsize+=LISTINCREMENT;
}
q=&（（*L）.elem[i-1]）;
for（p=&（（*L）.elem[（*L）.length-1]）;p>=q;--p）
*（p+1）=*p;
*q=e;
++（*L）.length;
returnOK;
}
statusGetElem（sqlist*L,inti,elemtype*e）
{
（*e）=（*L）.elem[i-1];
returnOK;
}
statusList_Delete（sqlist*L,inti）
{//删除线性表的第i个元素
if（i<1||i>（*L）.length）returnERROR;
elemtype*p;elemtype*q;
p=&（（*L）.elem[i]）;
q=p-1;intnum;
for（num=1;num<=（（*L）.length-i）;num++）
{（*q）=（*p）;
p++;q++;
}
（*L）.length--;
returnOK;
}
statusList_Travel（sqlist*L,status（*visit）（elemtypee））
{
//遍历线性表中的元素
inti=1;
for（i=1;i<=（（*L）.length）;i++）//循环（*L）.LENGTH次
{
printf（"第%d个元素为：
",i）;
（*visit）（（*L）.elem[i-1]）;
}
returnOK;
}
statusDisplay（elemtypee）{
printf（"%d\n",e）;
returnOK;
}
statusmain（）{
sqlistLIST;elemtypeELEM;
elemtype*e=&（ELEM）;
sqlist*L=&（LIST）;
printf（"执行操作：
\n"）;
printf（"InitList_Sq（L）;\nList_Insert（L,1,10）;\nList_Insert（L,2,20）;\nList_Insert（L,3,30）;\n"）;
InitList_Sq（L）;
List_Insert（L,1,10）;
List_Insert（L,2,20）;
List_Insert（L,3,30）;
List_Travel（L,Display）;
printf（"执行操作：
\n"）;
printf（"List_Delete（L,2）;\n"）;
List_Delete（L,2）;
List_Travel（L,Display）;
printf（"执行操作：
\n"）;
printf（"GetElem（L,2,e）;\nDisplay（ELEM）;"）;
GetElem（L,2,e）;
Display（ELEM）;
List_Travel（L,Display）;
getchar（）;
}
链式存储C程序：
#include
#include
typedefintelemtype;
typedefintstatus;
#defineERROR-1
#defineOK1
#defineOVERFLOW2008
typedefstructLnode{
elemtypedata;
structLnode*next;
}*Linklist;//头指针
statusInitLinklist（Linklist&name）
{
name=（Linklist）malloc（sizeof（Lnode））;
if（!
name）returnERROR;
name->next=0;//定义指针域为空
returnOK;
}
statusListInsert（Linklist&name,intnum,elemtypeelem）
{
//在带头节点的单链表name中第i个位置之前插入元素elem
Linklistp;
p=name;inti=0;
while（p&&inext;i++;}//寻找第num-1个节点并将P指向他
if（!
p||i>num-1）returnERROR;
Linklisttemp;
temp=（Linklist）malloc（sizeof（Lnode））;
temp->data=elem;
temp->next=p->next;
p->next=temp;
returnOK;
}
statusListDelete（Linklist&name,intnum）
{
//在带头结点的单链表name中删除第num个数据元素元素
Linklistp;
p=name;inti=0;
while（p&&inext;i++;}
if（!
p||i>num-1）returnERROR;
Linklisttemp=p->next;
p->next=p->next->next;//即使是删除最后一个元素，空指针也能继承
free（temp）;
}
statusGetElem（Linklist&name,intnum,elemtype&elem）
{
Linklistp;
p=name->next;
inti=1;
while（p&&inext;++i;}
if（!
p||i>num）returnERROR;
elem=p->data;
returnOK;
}
statusListChange（Linklist&name,intnum,elemtypeelem）
{
Linklistp;
p=name->next;inti=1;
while（p&&inext;}
p->data=elem;
returnOK;
}
statusListTravel（Linklistname,status（*visit）（elemtypei））
{
Linklistp;
p=name;inti=1;
do{
p=p->next;
printf（"第%d个元素为:
",i）;
（*visit）（p->data）;
i++;
//注意：
先移动指针再调用显示函数，因为dowhile循环的特点是，先执行循环体再判断while后的条件是否成立
}while（p->next）;
returnOK;
}
statusDisplay（elemtypei）{
printf（"%d\n",i）;
returnOK;
}
statusmain（）
{LinklistL;elemtypeelem;inti;
printf（"执行操作：
\nInitLinklist（L）\nfor（i=1;i<=5;i++）\n{ListInsert（L,i,i）;}\n"）;
InitLinklist（L）;
for（i=1;i<=5;i++）{ListInsert（L,i,i）;}
ListTravel（L,Display）;
printf（"执行操作：
\nListChange（L,2,99）\n"）;
ListChange（L,2,99）;
ListTravel（L,Display）;
printf（"执行操作：
\nListInsert（L,6,6）;\n"）;
ListInsert（L,6,6）;
ListTravel（L,Display）;
printf（"执行操作：
\nGetElem（L,3,elem）;\nDisplay（elem）;\n"）;
GetElem（L,3,elem）;
Display（elem）;
ListTravel（L,Display）;
printf（"执行操作：
\nListDelete（L,1）;\n"）;
ListDelete（L,1）;
ListTravel（L,Display）;
getchar（）;
returnOK;
}
六．实验结果
顺序存储C程序：
截图：
链式存储C程序：
七．总结和感想
通过这次实验，掌握了线性表的定义，顺序存储及链式存储的方法及基本操作。
学会了利用线性表的顺序存储结构完成一些数据的管理，实现数据通信元素的增加，删除等运算。
计算机系数据结构实验报告
---
（2）栈和队列
学生姓名：
学号：
专业班级：
实验类型：
□验证□综合■设计□创新实验日期：
2012/4/12实验成绩：
一．实验目的
深入了解栈和队列的特性，学会在实际问题下灵活运用它们。
二．问题描述
表达式求值运算是实现程序设计语言的基本问题之一，也是栈应用的一个典型例子。
设计并演示用算符优先级对算术表达式的求解过程。
三．实验要求
1．算法优先级别如下：
'+','-','*','/','（','）','#'
'+''>','>','<','<','<','>','>',
'-''>','>','<','<','<','>','>',
'*''>','>','>','>','<','>','>',
'/''>','>','>','>','<','>','>',
'（''<','<','<','<','<','=','',
'）''>','>','>','>','','>','>',
'#''<','<','<','<','<','','='
2．以字符序列的形式从终端输入语法正确、不含变量的算术表达式，利用给出的算符优先级关系，实现对算术四则混合运算的求解过程。
四．算法分析
顺序优先级队列触雷操作的实现方法是：
首先在遍历队列数据元素的基础上找出优先级最高的数据元素，然后依次把从原队列中第二个元素到队尾的所有元素前移一个位置，最后把队列的数据元素个数减1。
由于顺序优先级队列每次出列操作后，有一个前移数据结构元素过程，这样，数据元素都集中在顺序队列的前边部分，因此顺序优先级队列不存在像顺序队列那样的“假溢出”问题。
五．实验内容和过程
测试数据
1．输入数据：
20-3+（5-1）+8/4
正确结果：
23
2．输入数据：
2*9-6-（20+4）/（4-1）
正确结果：
4
代码：
C程序：
#include
#include
//typedefcharchar;
typedefintstatus;
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
#definestack_init_size100
#definestack_increament50
typedefstruct{
char*base;
char*top;
intstacksize;
intlength;
}charstack;
//----------------------------------
statusInitStack（charstack&S）{
S.base=（char*）malloc（stack_init_size*sizeof（char））;
if（!
S.base）returnOVERFLOW;
S.stacksize=100;
S.length=0;
S.top=S.base;
}
statusPush（charstack&S,chare）{
if（!
&S）returnERROR;
if（S.length==S.stacksize）{//若存储空间不够则重新分配
char*newbase;
newbase=（char*）realloc（S.base,（S.stacksize+stack_increament））;
if（!
newbase）returnOVERFLOW;
S.base=newbase;
}
*（S.top）=e;S.top++;S.stacksize++;//元素带入
returnOK;
}
statusPop（charstack&S,char&e）{
if（!
&S）returnERROR;
if（S.top==S.base）returnERROR;
e=*（S.top-1）;S.top--;S.stacksize--;
returnOK;
}
statusFreeStack（charstack&S）
{if（!
&S）returnERROR;
free（S.base）;
returnOK;
}
charGetTop（charstack&S）{
chare;
if（S.top==S.base）returnERROR;
e=*（S.top-1）;
returne;
}//gettop
#include"charstack.h"
#include"intstack.h"
#include
#include
#include
#include
#defineOPSETSIZE7
unsignedcharPrior[7][7]={//用二维数组表示表
'>','>','<','<','<','>','>',
'>','>','<','<','<','>','>',
'>','>','>','>','<','>','>',
'>','>','>','>','<','>','>',
'<','<','<','<','<','=','',
'>','>','>','>','','>','>',
'<','<','<','<','<','','='
};
charOP[OPSETSIZE]={'+','-','*','/','（','）','#'};//算符集合
floatOperate（floata,unsignedchartheta,floatb）{
switch（theta）{
case'+':
returna+b;
case'-':
returna-b;
case'*':
returna*b;
case'/':
returna/b;
default:
return0;
}
}//运算函数
statusIn（charTest,char*TestOp）{
boolFind=false;
for（inti=0;iif（Test==TestOp[i]）Find=true;
}
returnFind;
}//判断是否为运算符
intReturnOpOrd（charop,char*TestOp）{
inti;
for（i=0;iif（op==TestOp[i]）returni;
}
return0;
}//返回算符位序
charprecede（charAop,charBop）{
returnPrior[ReturnOpOrd（Aop,OP）][ReturnOpOrd（Bop,OP）];
}//判断优先级
floatEvaluateExpression（char*MyExpression）{//主函数
//算术表达式求值的算符优先算法。
//设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合。
charstackOPTR;//运算符栈，字符元素
intstackOPND;//运算数栈，实数元素
charTempData[20];
floatData,a,b;
chartheta,*c,x,Dr[2];
InitStack（OPTR）;
Push（OPTR,'#'）;
InitStack（OPND）;
c=MyExpression;
strcpy（TempData,"\0"）;//把src所指由NULL结束的字符串复制到dest所指的数组中TempData置0
while（*c!
='#'||GetTop（OPTR）!
='#'）{
if（!
In（*c,OP））{//不是运算符
Dr[0]=*c;
Dr[1]='\0';
strcat（TempData,Dr）;//把src所指字符串添加到dest结尾处（覆盖dest结尾处的'\0'）并添加'\0'。
c++;
if（In（*c,OP））{
Data=（float）atof（TempData）;
Push（OPND,Data）;
strcpy（TempData,"\0"）;//清空TempData,最长位数不能超过20位
}
}else{//不是运算符则进栈
switch（precede（GetTop（OPTR）,*c））{
case'<':
//栈顶元素优先权低
Push（OPTR,*c）;
c++;
break;
case'=':
//脱括号并接收下一字符
Pop（OPTR,x）;
c++;
break;
case'>':
//退栈并将运算结果入栈
Pop（OPTR,theta）;
Pop（OPND,b）;
Pop（OPND,a）;
Push（OPND,Operate（a,theta,b））;
break;
}//switch
}
}//while
returnGetTop（OPND）;
}//EvaluateExpression
statusmain（）{
floati=0;intj=0;charc;
do{
printf（"Welcome，请输入算符表达式：
（例如“3+2”，按E退出）\n"）;
charexp[50];
for（j=0;j<50;j++）
{
c=getchar（）;//每次读取一个
if（c!
=10）
exp[j]=c;
else
{if（exp[j-1]!
='#'）exp[j]='#';break;}//若忘记输入#则自动添加
}
if（exp[0]=='e'||exp[0]=='E'
升级会员 