川师数学院数据结构试验Word文档格式.docx
《川师数学院数据结构试验Word文档格式.docx》由会员分享，可在线阅读，更多相关《川师数学院数据结构试验Word文档格式.docx（62页珍藏版）》请在冰豆网上搜索。
（类C算法的程序实现）
（1）输入一组数据存入数组中，并将数据元素的个数动态地由输入函数完成。
求输入数据的最大值、最小值，并通过函数参数返回所求结果；
实验准备：
1）计算机设备；
2）程序调试环境的准备，如TC环境；
3）实验内容的算法分析与代码设计与分析准备。
实验步骤：
1.安装TC并设置好环境，如果已安装好，可以跳过此步；
2.录入程序代码并进行调试和算法分析；
对实验内容
（1）的操作步骤：
1）用类C语言描述算法过程；
2）用C语言环境实现该算法。
对实验内容
（2）的操作步骤：
1）完成算法的C实现；
2）分析其时间复杂度和空间复杂度。
3.编写实验报告。
实验结果：
//动态分配数组空间
#include"
stdio.h"
malloc.h"
intsize,i;
int*pArray;
int*p;
voidmalloc_size（）
{
pArray=（int*）malloc（size*（sizeof（int）））;
}
intinput_size（）
printf（"
pleaseinputthesize:
\n"
）;
size="
scanf（"
%d"
&
size）;
return0;
intinput_data（）
pleaseinputthevalue:
for（i=0;
i<
size;
i++）
{
printf（"
pArray[%d]="
i）;
scanf（"
pArray[i]）;
}
return*pArray;
intCompare（）
intx,y,i;
x=y=p[0];
if（x>
=p[i]）x=p[i];
if（y<
=p[i]）y=p[i];
min=%d\tmax=%d\n"
x,y）;
intOutput_data（）
p=pArray;
beforeofpaixu:
%d\t"
*pArray）;
pArray++;
voidpaixu（）
intx=0;
inti,j;
laterofpaixu:
for（j=i+1;
j<
j++）
{
if（p[i]>
=p[j]）
{
x=p[i];
p[i]=p[j];
p[j]=x;
}
}
p[i]）;
voidmain（）
clrscr（）;
input_size（）;
malloc_size（）;
input_data（）;
Output_data（）;
Compare（）;
paixu（）;
实验二线性表及其基本操作实验（2学时）
（1）熟练掌握线性表ADT和相关算法描述、基本程序实现结构；
（2）以线性表的基本操作为基础实现相应的程序；
（3）掌握线性表的顺序存储结构和动态存储结构之区分。
（类C算法的程序实现，任选其一。
具体要求参见教学实验大纲）
（1）一元多项式运算的C语言程序实现（加法必做，其它选做）；
（2）有序表的合并；
（3）集合的并、交、补运算；
1.录入程序代码并进行调试和算法分析；
2.编写实验报告。
//线性链表
#defineM6
typedefstructnode
intdata;
structnode*next;
}*Sqlist;
voidInitlialize（Sqlist&
L）
L=（Sqlist）malloc（sizeof（Sqlist））;
L->
next=NULL;
intGetlength（SqlistL）
inti=0;
Sqlistp=L->
next;
while（p!
=NULL）
i++;
p=p->
next;
returni;
intGetelem（SqlistL,inti）
intj=1,e;
while（j<
i）
j++;
e=p->
data;
第%d个元素是：
%d\n"
i,e）;
return1;
intLocatelem（SqlistL,intx）
=NULL&
&
p->
data!
=x）
p=p->
if（p==NULL）
return0;
else
%d是第%d个元素\n"
x,i）;
voidCreatlistF（Sqlist&
L,inta[],intn）//头插法
//从一个空表开始，读取字符数组a中字符生成新结点，将读取数据存放到新结点数据域，
//再将新结点插入当前链表表头、直至结束
Sqlists;
inti;
n;
s=（Sqlist）malloc（sizeof（Sqlist））;
s->
data=a[i];
s->
next=L->
L->
next=s;
voidCreatlistR（Sqlist&
L,inta[],intn）//尾插法
//将新结点插到当前链表表尾，为此必须新增一个尾指针r,使其始终指向当前链表的尾结点
Sqlists,r;
r=L;
next=NULL;
r->
next=s;
r=s;
intInselem（Sqlist&
L,inti,intx）
//1、将所建新结点s的next域指向p的下一结点：
s->
next=p->
next
//2、将结点p的next域指向新结点s：
next=s
intj=1;
Sqlists,p=L->
s=（Sqlist）malloc（sizeof（Sqlist））;
data=x;
if（i<
1||i>
Getlength（L））
i-1）
在第%d个位置插入数据：
i,x）;
next=p->
p->
intDelelem（Sqlist&
L,inti）
Sqlistp,q;
p=L;
q=p->
next=q->
free（q）;
voidDisplist（SqlistL）
p->
data）;
printf（“\n”）;
voidinput（int*pArray,intn）
请输入数组数据（共含%d个元）:
n）;
for（inti=0;
i++）
Scanf（“%d”,&
intmain（intargc,char*argv[]）
SqlistL;
intArray[M],Select;
Initlialize（L）;
do{
请输入选择方法（1表示头插法，2表示尾插法,0表示结束）：
Select）;
switch（Select）
case1:
按头插法建立线性表:
input（Array,M）;
CreatlistF（L,Array,M）;
break;
case2:
按尾插法建立线性表:
CreatlistR（L,Array,M）;
原线性表数据为:
Displist（L）;
Getelem（L,3）;
Locatelem（L,2）;
Inselem（L,5,5）;
修改后的线性表数据为:
//Delelem（L,4）;
}while（Select!
=0）;
//运行结果:
实验三栈和队列实验（6学时）
（1）熟练掌握栈和队列的抽象数据类型及其结构特点；
（2）实现基本的栈和队列的基本操作算法程序。
（类C算法的程序实现，任选其一）
（1）设计与实现基本的堆栈和队列结构下的各种操作（如堆栈的PUSH、POP等操作）（必做）；
（2）以表达式计算为例，完成一个可以进行算术表达式计算功能的算法设计与实现（选做）；
2.编写实验报告。
（1）/*队列存储*/
typedefintstatus;
#defineQueueSize10
typedefstructsqqueue
chardata[QueueSize];
intfront,rear;
}SqQueue;
voidInitQueue（SqQueue&
qu）
qu.front=qu.rear=0;
statusEnQueue（SqQueue&
qu,charx）
if（（qu.rear+1）%QueueSize==qu.front）
qu.rear=（qu.rear+1）%QueueSize;
qu.data[qu.rear]=x;
statusDeQueue（SqQueue&
qu,char&
x）
if（qu.rear==qu.front）
qu.front=（qu.front+1）%QueueSize;
x=qu.data[qu.front];
statusGetHead（SqQueuequ,char&
if（qu.rear==qu.front）
x=qu.data[（qu.front+1）%QueueSize];
statusQueueEmpty（SqQueuequ）
if（qu.rear==qu.front）
return1;
else
SqQueuequ;
chare;
InitQueue（qu）;
Queue%s\n"
（QueueEmpty（qu）==1?
"
Empty"
:
NotEmpty"
））;
insera\n"
EnQueue（qu,'
a'
inserb\n"
b'
inserc\n"
c'
inserd\n"
d'
GetHead（qu,e）;
Queueoftopelemis:
%c\n"
e）;
showofQueue:
while（!
QueueEmpty（qu））
DeQueue（qu,e）;
%c\t"
（2）/*用栈实现对表达式的求值运算*/
stdlib.h"
/*数据类型转换库函数*/
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
#defineSTACK_INIT_SIZE100/*初始分配量*/
#defineSTACKINCREMENT10/*存储空间的分配增量*/
typedefintStatus;
typedefcharElemType;
typedefElemTypeOperandType;
/*操作数*/
typedefcharOperatorType;
typedefstruct
ElemType*base;
ElemType*top;
intstacksize;
}SqStack;
StatusInitStack（SqStack&
S）
/*构造一个空栈S*/
S.base=（ElemType*）malloc（STACK_INIT_SIZE*sizeof（ElemType））;
if（!
S.base）exit（OVERFLOW）;
/*存储空间失败*/
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
returnOK;
}/*InitStack*/
StatusGetTop（SqStackS）
/*若栈不空，则用e返回S的栈顶元素*/
ElemTypee;
if（S.top==S.base）returnERROR;
e=*（S.top-1）;
returne;
}/*GetTop*/
StatusPush（SqStack&
S,ElemTypee）/*插入元素e为新的栈顶元素*/
if（S.top-S.base>
=S.stacksize）
/*栈满，追加存储空间*/
S.base=（ElemType*）realloc（S.base,（S.stacksize+STACKINCREMENT）*sizeof（ElemType））;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
*S.top++=e;
}/*Push*/
StatusPop（SqStack&
S,ElemType&
e）/*取栈顶元素，用e返回*/
/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；
否则返回ERROR*/
if（S.top==S.base）returnERROR;
e=*--S.top;
}/*Pop*/
charIn（charc,charOP[]）/*判断字符c是否属于运算符*/
if（c>
=35&
c<
=47）
/*常见操作符（如：
'
#'
、'
（'
）'
+'
-'
*'
\'
等）的ASCII码在35到47之间*/
elsereturn0;
charOP[8]={'
'
/'
\0'
};
/*定义有所要用到的操作符构成的数组OP[8]*/
intm[7][7]={1,1,2,2,2,1,1,
1,1,2,2,2,1,1,
1,1,1,1,2,1,1,
2,2,2,2,2,0,-1,
1,1,1,1,-1,1,1,
2,2,2,2,2,-1,0};
/*各运算符间优先级别的关系*/
/*以上：
1表示‘>
’；
2表示‘<
0表示‘=’；
-1表示‘不存在’*/
charPrecede（chari,charj）/*比较数组OP[]中字符i与数组OP中字符j的优先权*/
inta,b;
char*p;
for（p=OP,a=0;
*p!
='
;
p++,a++）
if（*p==i）break;
for（p=OP,b=0;
p++,b++）
if（*p==j）break;
if（m[a][b]==1）return'
>
elseif（m[a][b]==2）return'
<
elseif（m[a][b]==0）return'
elsereturn'
O'
charOperate（chara,chartheta,charb）/*对运算数a、b按操作符theta进行二元运算*/
if（a>
47）a=atoi（&
a）;
/*将字符数转化为整型数*/
if（b>
47）b=atoi（&
b）;
switch（theta）
{
case'
returna+b;
break;
returna-b;
returna*b;
returna/b;
return'
1'
OperandTypeEvaluateExpression（）/*算术表达式求值的算符优先算法*/
SqStackOPTR,OPND;
/*设OPTR、OPND分别运算符栈和运算数栈*/
OperandTypea,b,c;
OperatorTypetheta;
InitStack（OPTR）;
Push（OPTR,'
InitStack（OPND）;
c=getchar（）;
while（c!
||GetTop（OPTR）!
）
if（!
In（c,OP））{Push（OPND,c）;
c=getchar（）;
switch（Precede（GetTop（OPTR）,c））
:
Push（OPTR,c）;
c=getchar（）;
Pop（OPTR,c）;
Pop（OPTR,theta）;
Pop（OPND,b）;
Pop（OPND,a）;
Push（OPND,Operate（a,theta,b））;
returnGetTop（OPND）;
intmain（）
（请输入运算表达式：
以#为结束符）\n"
inta;
a=（int）EvaluateExpression（）;
/*执行函数EvaluateExpression（），将表达式的最终值强制转换为整型，并用a返回*/
a）;
getchar（）;
}
测试结果为：
①表达式中包含+、-、*的情况；
②表达式中包含（）、+、-、*的情况；
③表达式中包含（）、+、-、*、/的情况；
④表达式中出现负数的情况；
实验四字符串
升级会员 