最新电大《数据结构》实验报告Word下载.docx
《最新电大《数据结构》实验报告Word下载.docx》由会员分享，可在线阅读，更多相关《最新电大《数据结构》实验报告Word下载.docx（34页珍藏版）》请在冰豆网上搜索。
head=create（PWRS）;
printf（"
所有评委打分信息如下:
\n"
）;
print（head）;
//显示当前评委打分
calc（head）;
//计算成绩
该选手去掉1最高分和1最低分后的有效评委成绩:
//显示去掉极限分后的评委打分
}
voidinput（NODE*s）
请输入评委的姓名:
"
scanf（"
%S"
&
s->
data.name）;
年龄:
%d"
data.age）;
打分:
%f"
data.score）;
}
voidoutput（NODE*s）
{
printf（"
评委姓名:
%8s,年龄:
%d,打分:
%2.2f\n"
s->
data.name,s->
data.age,s->
}
NODE*create（intm）
NODE*head,*p,*q;
inti;
p=（NODE*）malloc（sizeof（NODE））;
head=p;
q=p;
p->
next=NULL;
for（i=1;
i<
=m;
i++）{
input（p）;
q->
next=p;
return（head）;
}
voidprint（NODE*h）
{for（inti=1;
（（i<
=PWRS）&
&
（h->
next!
=NULL））;
h=h->
next;
output（h）;
intcalc（NODE*h）
NODE*q,*p,*pmin,*pmax;
p=h->
//指向首元结点
pmin=pmax=p;
//设置初始值
sum+=p->
data.score;
p=p->
for（;
p!
=NULL;
p=p->
next）
{
if（p->
data.score>
pmax->
data.score）pmax=p;
data.score<
pmin->
data.score）pmin=p;
cout<
<
"
给出最高分的评委姓名：
data.name<
年龄：
data.age<
分值：
endl;
给出最低分的评委姓名：
sum-=pmin->
sum-=pmax->
for（q=h,p=h->
q=p,p=p->
next）
if（p==pmin）{q->
next=p->
p=q;
}//删除最低分结点
if（p==pmax）{q->
}//删除最高分结点
ave=sum/（PWRS-2）;
该选手的最后得分是：
ave<
return1;
程序运行结果如下:
线性表的顺序存储结构
用顺序表A记录学生的信息，编写程序：
（1）将A表分解成两个顺序表B和C，使C表中含原A表中性别为男性的学生，B表中含原表中性别为女性的学生，要求学生的次序与原A表中相同。
（2）分别求男生和女生的平均年龄
（1）建立学生信息的顺序表A。
（2）显示B表和C表中的相关信息。
（3）显示计算结果。
【实验步骤;
】
（3）输入程序代码，
string.h>
//包含库函数strcpy的头文件
#defineNULL0
structstudent//定义学生信息
{charname[8];
intsex;
//0女:
1:
男
typedefstructstudentSTD;
intcreate（STD*m）;
//创建顺序表
intcalc（STD*m,STD*n,STD*r,float&
Fage,float&
Mage）;
//计算、数据处理
voidprint（STD*m）;
constintMAX=100;
//定义人数
voidmain（）
STDA[MAX];
STDB[MAX];
STDC[MAX];
floatage1=0,age2=0;
//age1男age2女
create（A）;
学生总表A记录如下:
\n"
print（A）;
calc（A,B,C,age1,age2）;
女生名册B记录如下:
print（B）;
男生名册C记录如下:
print（C）;
intcreate（STD*m）
intn;
printf（"
请输入班级总人数:
\n"
scanf（"
n）;
m[0].age=n;
//置顺序表长度
请输入学生信息：
for（inti=1;
=n;
i++）
{
printf（"
姓名:
scanf（"
%s"
m[i].name）;
性别0女1男:
m[i].sex）;
m[i].age）;
return1;
Mage）
{inti,j=1,k=1;
n[0].age=r[0].age=0;
for（i=1;
=m[0].age;
i++）
{if（m[i].sex==0）
strcpy（n[j].name,m[i].name）;
n[j].sex=m[i].sex;
n[j].age=m[i].age;
n[0].age++;
Mage+=m[i].age;
j++;
else
strcpy（r[k].name,m[i].name）;
r[k].sex=m[i].sex;
r[k].age=m[i].age;
r[0].age++;
Fage+=m[i].age;
k++;
Mage=Mage/n[0].age;
Fage=Fage/r[0].age;
女生的平均年龄是：
Mage<
男生的平均年龄是：
Fage<
voidprint（STD*m）
printf（"
%3s,性别（0女1男）:
%d,年龄:
%d\n"
m[i].name,m[i].sex,m[i].age）;
}
l程序运行结果如下:
实验结束。
实验结论：
线性表采用链式存储（链表）时：
以结构变量存储结点，动态生成结点，以指针链接结点，能有效利用存储空间，插入删除方便，但不能随机访问.单向链表可从某结点访问到后继结点。
单向链表操作的关键步骤：
建立链表的头插法：
指针变量p开辟单元，生成结点，指针变量q始终指向头结点，操作为：
p->
next=q->
尾插法：
指针变量q始终指向尾结点，p指针开辟单元，生成结点：
?
插入：
p所指向结点的后面插入新结点s所指结点s->
next=s;
删除：
p，q指向相邻结点，q所指结点是p所指结点的后继，删除q所指结点，p->
遍历：
实验二栈、列队、递归程序设计
2.1栈和队列的基本操作
编写一个算法，输出指定栈中的栈底元素，并使得原栈中的元素倒置。
（1）正确理解栈的先进后出的操作特点,建立初始栈，通过相关操作显示栈底元素。
（2）程序中要体现出建栈过程和取出栈底元素后恢复栈的入栈过程，按堆栈的操作规则打印结果栈中的元素。
（4）运行PC中的MicrosoftVisualC++6.0程序，
（5）点击“文件”→“新建”→对话窗口中“文件”→“c++SourceFile”→在“文件名”中输入“X1.cpp”→在“位置”中选择储存路径为“桌面”→“确定”，
（6）输入程序代码，
#defineMaxSize100
typedefcharElemType;
typedefstruct
ElemTypedata[MaxSize];
inttop;
//栈顶指针
}SeqStack;
//定义栈
ElemTypeelem[MaxSize];
intfront,rear;
//队首和队尾指针
}SqQueue;
//定义队列
//---初始栈函数
voidInitStack（SeqStack*&
s）
s=（SeqStack*）malloc（sizeof（SeqStack））;
s->
top=-1;
//----进栈函数
intPush（SeqStack*&
s,ElemTypee）
if（s->
top==MaxSize-1）
return0;
top++;
data[s->
top]=e;
//---显示栈函数
voidDispStack（SeqStack*s）
for（i=s->
top;
i>
=0;
i--）
%c"
data[i]）;
//---显示栈底元素
voidDispBottomStack（SeqStack*s）
data[0]）;
//先进后出,栈底元素为第一个元素,即data[0]
//---判空栈函数
intStackEmpty（SeqStack*s）
return（s->
top==-1）;
//---出栈函数
intPop（SeqStack*&
s,ElemType&
e）
top==-1）
e=s->
top];
top--;
//---初始队列函数
voidInitQueue（SqQueue*&
q）
q=（SqQueue*）malloc（sizeof（SqQueue））;
front=q->
rear=0;
//---入队列函数
intInQueue（SqQueue*&
q,ElemTypee）
if（（q->
rear+1）%MaxSize==q->
front）//队满
rear=（q->
rear+1）%MaxSize;
elem[q->
rear]=e;
//---出队列函数
intOutQueue（SqQueue*&
q,ElemType&
if（q->
front==q->
rear）//队空
front=（q->
front+1）%MaxSize;
e=q->
front];
//---判空队列函数
intQueueEmpty（SqQueue*q）
return（q->
rear）;
//-----主程序
ElemTypee;
SeqStack*s;
（1）初始化栈s\n"
InitStack（s）;
（2）栈为%s\n"
（StackEmpty（s）?
空"
:
非空"
））;
（3）依次进栈元素a,b,c,d,e\n"
Push（s,'
a'
//入栈元素1
b'
//入栈元素2
c'
//入栈元素3
d'
//入栈元素4
e'
//入栈元素5
（4）栈为%s\n"
（5）从栈顶到栈底元素:
DispStack（s）;
（6）栈底元素为:
DispBottomStack（s）;
（7）出栈/入队列序列:
SqQueue*q;
InitQueue（q）;
while（!
StackEmpty（s））
Pop（s,e）;
//出栈
e）;
InQueue（q,e）;
//入队
（8）栈为%s,"
队列为%s\n"
（QueueEmpty（q）?
（9）出队列/入栈序列:
QueueEmpty（q））
{OutQueue（q,e）;
//出队
Push（s,e）;
//入栈
（10）栈为%s,"
free（q）;
//释放队列
（11）从栈顶到栈底元素:
free（s）;
//释放栈
2.2递归程序设计
给定一个5位的十进制正整数，用递归法分别编制程序：
（1）要求从低位到高位逐次输出各位数字。
（2）要求从高位到低位逐次输出各位数字。
（1）比较题中两种不同要求的递归程序设计和执行过程差别。
（2）正确理解递归程序的执行过程。
点击“文件”→“新建”→对话窗口中“文件”→“c++SourceFile”→在“文件名”中
（2）输入“X1.cpp”→在“位置”中选择储存路径为“桌面”→“确定”，
（3）输入程序代码
#include<
math.h>
voidout（intn,inti）//从高位到低位输出函数
intx,y;
y=int（pow（10,i））;
if（n!
=0）
x=n/y;
n=n-x*y;
%d"
x）;
elseprintf（"
0"
i--;
if（i>
=0）out（n,i）;
voidout1（intm,intj）//从低位到高位输出函数
intx,z;
if（m!
x=int（m/10）;
z=m-x*10;
m=x;
z）;
j--;
if（j>
=0）out1（m,j）;
intm,n,o,x,i,j;
输入需要排列的数字:
scanf（"
o）;
m=n=o;
x=n;
i=-1;
while（x!
x=x/10;
i++;
}//求出i为十进制正整数位数
j=i;
从高位到低位逐次输出各位数字:
out（n,i）;
从低位到高位逐次输出各位数字:
out1（m,j）;
程序运行结果如下:
实验结论:
栈和队列是运算受限制的线性表
栈：
后进先出（LIFO）
例:
进栈b,c,d,e,f出栈可能为f,e,d,c,b;
b,c,d,e,f;
c,b,e,d,f•••但不可能是e,d,f,b,c
队列：
先进先出（FIFO）
例：
入队1,2,3,4,5出队1,2,3,4,5
实验三二叉树
3.1二叉树的顺序存储结构和链式存储结构
设一棵完全二叉树用顺序存储方法存储于数组tree中，编写程序：
（1）根据数组tree，建立与该二叉树对应的链式存储结构。
（2）对该二叉树采用中序遍历法显示遍历结果。
（1）在主函数中，通过键盘输入建立设定的完全二叉树的顺序存储结构。
（2）设计子函数，其功能为将顺序结构的二叉树转化为链式结构。
（3）设计子函数，其功能为对给定二叉树进行中序遍历，显示遍历结果。
（4）通过实例判断算法和相应程序的正确性。
（7）运行PC中的MicrosoftVisualC++6.0程序，
（8）点击“文件”→“新建”→对话窗口中“文件”→“c++SourceFile”→在“文件名”中输入“X1.cpp”→在“位置”中选择储存路径为“桌面”→“确定”，
（9）输入程序代码，
memory.h>
#defineMaxSize10
typedefstructnode
chardata;
structnode*left,*right;
}NODE;
voidCreab（char*tree,intn,inti,NODE*p）;
voidInorder（NODE*p）;
NODE*p;
chartree[MaxSize];
intn=1;
inti=1;
请输入完全二叉数的节点值（连续输入字符，以回车结束输入。
）:
while（（tree[n]=getchar（））!
='
\n'
）n++;
tree[n]='
;
p=NULL;
Creab（tree,n,i,p）;
Inorder（p）;
voidCreab（char*tree,intn,inti,NODE*p）
if（i>
=n）p=NULL;
else
p=（NODE*）mall
升级会员 