数据结构上机实验报告.docx
《数据结构上机实验报告.docx》由会员分享，可在线阅读，更多相关《数据结构上机实验报告.docx（33页珍藏版）》请在冰豆网上搜索。
数据结构上机实验报告
数据结构上机
实验报告
谭文治
电信0801
080900120
【实验一】线性表
【实验目的】：
1．掌握线性表的两类存储结构（顺序存储结构和链式存储结构）的描述方法。
2．掌握在顺序结构中实现查找、插入、删除操作的基本方法。
3．掌握在各种链表结构中实现查找、插入、删除操作的基本方法。
【实验内容】
【1】已知线性表LA的数据元素（n个，n为偶数），现要求将LA拆开成两个新的线性表LB，LC。
要求LB中的数据元素为LA中的奇数位序的数据元素（a1,a3,…,an-1），LC中的数据元素为LA中的偶数位序的数据元素（a2,a4,…,an）。
【程序设计细想】：
建立三个线性表la,lb,lc，对线性表la进行输入，然后利用循环结构对la中奇数位序的元素对lb进行插入操作，对偶数位序的元素对lc进行插入操作，从而得到线性表lb和lc。
【程序代码】：
#include
#include
#definemax600//定义线性表的最大长度
typedefstruct{
char*elem;
charlist[max];//线性表
intlength;//length指示当前线性表的长度
}sqlist;
voidinitial（sqlist&）;//初始化线性表
voidinsert（sqlist&,int,char）;//在线性表中插入元素
voidinitlist（sqlist&）;
voidprint（sqlist）;//显示线性表中所有元素
voidmain（）
{sqlistla,lb,lc;//la,lb,lc为线性表
initial（la）;
initlist（lb）;
initlist（lc）;
inti;
for（i=0;i{if（i%2==0）insert（lb,i/2,la.list[i]）;//奇数位次元诩插入lb
elseinsert（lc,i/2,la.list[i]）;//偶数位次元素插入lc
}
printf（"\n您输入的线性表元素为:
\n\n"）;
print（la）;
printf（"线性表的奇数位次的元素为：
\n\n"）;
print（lb）;
printf（"线性表的偶数位次的元素为：
\n\n"）;
print（lc）;
}
voidinitial（sqlist&v）
{printf（"****本程序可以实现线性表奇偶位序的元素分别输出****\n\n\n"）;
inti,a;
printf（"请输入一个偶数作为线性表的长度：
\n\n"）;
scanf（"%d",&a）;
while（a%2!
=0）
{printf（"\n你刚才输入的是奇数，请重新输入一偶数：
\n\n"）;
scanf（"%d",&a）;}
v.length=a;
printf（"\n请输入线性表的元素（个数为你输入的偶数,超过个数的元素程序不计入）：
\n\n"）;
getchar（）;
for（i=0;iscanf（"%c",&v.list[i]）;//对la进行赋值
}
voidinitlist（sqlist&v）//构造一个空的线性表
{v.elem=（char*）malloc（max*sizeof（char））;
v.length=0;
}
voidinsert（sqlist&v,intj,charc）
{v.list[j]=c;//插入c
v.length++;
}
voidprint（sqlistv）
{inti;
for（i=0;i{printf（"%c",v.list[i]）;}//输出线性表元素
printf（"\n\n"）;
}
【调试和运行】
经过调试运行，程序均得到正确结果，例如输入9个元素adjfhres得到结果如下图：
【收获与体会】：
通过这个程序的设计我加深了对线性表基本操作的理解与掌握，对线性表的初始化，插入操作有了进一步的掌握。
【2】已知线性表LA的数据元素（n个），现要求将LA的数据元素复制到另一个线性表LB中。
【程序设计思想】：
建立两个线性表la,lb。
对la进行输入赋值操作，然后对la线性表的每个元素依次对lb进行插入操作，从而得到线性表lb。
【程序代码】：
#include
#include
#definemax600//定义线性表最大长度
typedefstruct{
char*elem;
charlist[max];//线性表
intlength;
}sqlist;
voidinitial（sqlist&）;//初始化线性表
voidinitlist（sqlist&）;
voidprint（sqlist）;//输出线性表
voidmain（）
{printf（"*****************本程序可以实现线性表的复制******************\n"）;
sqlistla,lb;//声明线性表
initial（la）;
initlist（lb）;
inti;
for（i=0;i{lb.list[i]=la.list[i];
lb.length++;}
print（lb）;
}
voidinitial（sqlist&v）//输入元素，构造线性表
{inti;
printf（"\n请输入你想输入的线性表的长度：
\n"）;
scanf（"%d",&v.length）;
printf（"\n请输入线性表的元素（超过长度的元素程序不计入）：
\n"）;
getchar（）;
for（i=0;iscanf（"%c",&v.list[i]）;
}
voidinitlist（sqlist&v）//建立空线性表
{v.elem=（char*）malloc（max*sizeof（char））;
v.length=0;
}
voidprint（sqlistv）//输出线性表元素
{inti;
printf（"\n复制得到的线性表为：
\n"）;
for（i=0;i{printf（"%c",v.list[i]）;}
printf（"\n"）;
}
【调试和运行】：
对程序进行调试和运行，输入9个元素tanwenzhi，得到结果如下图：
【收获与体会】：
通过对程序的设计，编译，运行，我进一步加深了对线性表的掌握，熟练了线性表的插入操作，对以后复杂的编程奠定了基础。
【3】：
设有一个线性表采用顺序存储结构，表中的数据元素值为正整数（n个）。
设在O（n）时间内，将线性表分成两为两部分，其中左半部分每个元素都小于原表的第一个元素，而右半部分则相反。
【程序设计思想】：
首先要建立一个线性表，对其进行赋值操作，然后进入主程序阶段，即voidpaixu（sqlistv）
{inti=0,j=v.length-1,x=v.list[0];
while（i{
while（ix）j=j-1;if（iwhile（i}
v.list[i]=x;
}
把第一个元素作为比较基准，进行上式的循环，从而把小于第一个元素的排在左边，大于第一个元素的排在右边。
达到程序要求。
【程序代码】：
#include
#include
#definemax600
typedefstruct{
int*elem;
intlist[max];
intlength;
}sqlist;
voidinitial（sqlist&）;
voidpaixu（sqlist）;
voidprint（sqlist）;
voidmain（）
{printf（"**********本程序实现以第一个元素为标准左小右大分布***********\n"）;
sqlistl;
initial（l）;
inti=0,j=l.length-1,x=l.list[0];
while（i{
while（ix）j=j-1;if（iwhile（i}
l.list[i]=x;
print（l）;
}
voidinitial（sqlist&v）
{inti;
v.elem=（int*）malloc（max*sizeof（int））;
printf（"\n请输入线性表的长度：
\n"）;
scanf（"%d",&v.length）;
printf（"\n请输入%d个正整数：
\n",v.length）;
getchar（）;
for（i=0;iscanf（"%d",&v.list[i]）;
}
voidprint（sqlistv）
{
printf（"\n重新分布以后的数列为:
\n"）;
inti;
for（i=0;iprintf（"\n"）;
}
【调试和运行】：
对写好的程序进行编译通过无误，运行程序，输入八个整数：
35123414567367，运行得到的结果如下，达到了程序要求。
【收获与体会】：
通过对本程序的编写，刚开始对排序的算法感觉无从下手，通过耐心仔细的思考，得到了上面的排序程序，体会到编程序的灵活多变，不能固定思维，要善于思考简捷易懂的算法。
【4】：
设线性表LA＝（a1,a2,…,am），LB＝（b1,b2,…,bn）。
试编写一个算法，将LA、LB合并为线性表LC，使
要求LA、LB和LC均以单链表为存储结构，且LC表利用LA和LB中结点空间，这里m和n的值没有保存在头结点中，并分析算法时间复杂度。
【程序设计思想】：
首先建立三个线性表，对其中两个个进行赋值操作，得到原始的线性表，然后通过建立循环结构，再循环结构中判断出前两个线性表的元素的多少，根据判断的结果，分别对第三个空线性表进行插入操作，以达到程序的要求。
【程序核心语句】：
voidmerge1（LinkList&A,LinkList&B,LinkList&C）//把链表A和B合并为C,A和B的元素间隔排列
{
p=A->next;q=B->next;
C=A;
while（p&&q）
{s=p->next;p->next=q; //将B的元素插入
if（s）
{t=q->next;q->next=s;//如A非空,将A的元素插入
}
p=s;
q=t;
}
【收获与体会】：
通过对本程序的设计，进一步掌握了线性表的操作，熟悉了线性表的合并的操作，线性表的合并方式很多，要找到合适的简捷的方法达到最高的效率。
这些都要在不断的编写过程中去摸索去掌握。
【5】：
约瑟夫问题：
设编号为1，2，…，n的n（n>0）个人按顺时针方向围坐一圈，每人持有一正整数密码。
开始时任选一个正整数作为报数上限值m，从第一个人开始顺时针方向自1起顺序报数，报到m时停止报数，报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人起重新从1报数。
如此下去，直到所有人全部出列为止。
令n最大值取30。
要求设计一个程序模拟此过程，求出出列编号序列（采用循环单链表结构）。
【程序设计思想】：
约瑟夫问题是一道经典的链表程序，有各种各样的算法细想，各种各样实现算法，这些都体现了程序的多样性。
对于这一经典问题，我采用循环链表结构，运用循环结构模拟游戏的过程，对于人数进行赋值，对于每个人的密码进行输入赋值，然后指定第一个密码，运用循环结构，通过主程序的作用，对出列号码进行存储，集中输出。
【程序设计代码】：
#include
#include
typedefstructnode////循环链表结构
{
intnum,code;
structnode*next;
}LinkList;//建立单链表
voidmain（）
{printf（"*********本程序为约瑟夫问题的解决***********\n"）;
intm=0,n=0,i=0,j=0;
LinkList*head,*s,*r,*p;//声明
printf（"\n请输入第一个m值:
\n"）;
scanf（"%d",&m）;
printf（"\n请输入总人数:
\n"）;
scanf（"%d",&n）;
printf（"\n输入%d个人依次的密码（!
数字只限于1到%d!
并以空格隔开）:
\n",n,n）;
head=（LinkList*）malloc（sizeof（LinkList））;//分配存储空间
scanf（"%d",&head->code）;
head->num=1;
r=head;
for（i=1;i{
s=（LinkList*）malloc（sizeof（LinkList））;//分配空间
scanf（"%d",&s->code）;
s->num=i+1;
s->next=NULL;
r->next=s;
r=r->next;
}
r=head;
s->next=head;
printf（"\n出列顺序为:
\n"）;//输出一次出列的序号
for（j=n;j>0;j--）
{
if（m==1）
{
printf（"%d",r->num）;
p->next=r->next;
r=r->next;
m=r->code;
}
else
{
for（i=1;i{
r=r->next;
}
p=r;
s=r->next;
printf（"%d",s->num）;
r->next=s->next;
r=s->next;
m=s->code;
free（s）;//释放s
}
}
printf（"\n"）;
}
【调试和运行】：
对程序进行编译无误，运行输入第一个密码为4，人数为23，每个人的密码依次为：
1、9、5、3、6、2、8、10、4、7、19、15、12、11、13、17、20、16、18、14、23、21、、22.运行得到结果如下图：
【收获与体会】：
约瑟夫问题是经典的一个算法，可以用数组以及很多方式来完成，这次采用循环链表来完成，进一步掌握了循环链表的操作，对于循环列表有了深一层次的理解，对于程序的编写，要善于灵活运用所学的编程知识，去摸索尽可能简捷的方法去实现一个程序。
【实验二】栈和队列的基本操作
【实验目的】：
1．掌握栈和队列两种抽象数据类型的特点。
2．掌握顺序栈和链栈入栈、出栈的实现算法。
3．掌握栈满和栈空的描述方法。
4．掌握循环队列（顺序表示）和链队列入队、出队的实现算法。
5．掌握队满和队空的描述方法。
【实验内容】：
【1】：
试编写算法，在顺序存储结构下实现堆栈的下列运算：
（1）initstk（s）。
初始化操作，建立一个空栈s；
（2）emptystk（s）。
判定栈是否为空；
（3）pushstk（s）。
如果栈s不满，在栈顶插入x；
（4）popstk（s）。
如果栈s不空，删除栈顶元素，并返回该元素的值；
（5）getstk（s）。
如果栈s不空，返回栈顶元素。
【程序设计思想】：
这些都是栈的基本操作的训练，按照栈的定义和基本的操作来实现就可以了，考查的是基本操作的运用。
【程序核心算法】：
#definestack_init_size100;
#definestackincreament10;
typedefstruct{
selemtype*base;
selemtype*top;
intstacksize;
}sqstack;
（1）初始化操作，建立一个空栈s
voidinitstk（sqstack&s）
{s.base=（selemtype*）malloc（stack_init_size*sizeof（selemtype））;
if（!
s.base）exit（overflow）;
s.top=s.base;
s.stacksize=stack_init_size;
returnok;
}
（2）判定栈是否为空
voidemptystk（sqstacks）
{
if（s.top==s.base）returnyes;
elsereturnno;
}
（3）如果栈不满，在栈顶插入x
voidpushstk（sqstack&s,selemtypex）
{if（s.top-s.base*s.top++=e;
returnok;
}
（4）如果栈不空，删除栈顶元素，并返回该元素值
voidpopstk（sqstack&s,selemtype&e）
{
if（s.top==s.base）returnerror;
e=*--s.top;
returnok;
}
（5）如果栈不空，返回栈顶元素
voidgetstk（sqstacks,selemtype&e）
{if（s.top==s.base）returnerror;
e=*（s.top-1）;
returnok;
}
【收获与体会】：
训练的是栈的基本操作，进一步掌握了栈的基本操作，基础知识要牢固，便于灵活的运用。
【2】试编写算法，实现链队列的下列操作算法：
（1）initlq（q）。
初始化操作，建立一个空队列q；
（2）emptylq（q）。
判定队列q是否为空；
（3）enterlq（q）。
进队列；
（4）deletelq（q）。
出队列。
【程序设计思想】：
这里练习的是队列的基本操作，按照队列的定义与基本的操作去编写就好。
要注意判断队列的空满。
【程序核心算法】：
typedefstructqnode{
qelemtypedata;
structqnode*next;
}qnode,*queueptr;
typedefstruct{
queueptrfront;
queueptrrear;
}linkqueue;
初始化操作，建立一个空队列q
voidinitlq（linkqueue&q）
{q.front=q.rear=（queueptr）malloc（sizeof（qnode））;
if（!
q.front）exit（overflow）;
q.front->next=null;
returnok;
}
判定队列q是否为空
voidemptylq（linkqueueq）
{
if（q.front==q.rear）returnyes;
elseretunno;
}
进队列
voidenterlq（linkqueue&q,qelemtypee）
{
p=（queueptr）malloc（sizeof（qnode））;
if（!
p）exit（overflow）;
p->data=e;p->next=null;
q.rear->next=p;
q.rear=p;
returnok;
}
出队列
voiddeletelq（linkqueue&q）
{
if（q.front==q.rear）returnerror;
p=q.front->next;
q.front->next=p->next;
if（q.rear==p）q.rear=q.front;
free（p）;
returnok;
}
【收获与体会】：
通过对队列基本操作算法的编写，进一步掌握了其基本操作的方法与思想。
为今后复杂程序的编写奠定了基础。
【实验三】串的基本操作
【实验目的】：
1、掌握串的基本操作。
2、掌握串函数的基本使用方法。
3、加深对串的理解，逐步培养解决实际问题的编程能力。
【实验内容】：
假设以顺序存储结构存放字符串，试编写算法，实现下列基本操作（用C语言编写）：
（1）CreatString（&S）。
输入并建立顺序存储的字符串S；
（2）SubString（&T,S,pos,len）。
求S串从pos开始长度为len的子串放入T串；
（3）StrInsert（&S,i,T）。
在串S的第i个字符前插入T；
（4）StrDelele（&T,S,i,len）。
从串S中删除第i个字符起长度为len的子串送到T中。
【程序核心算法】：
typedefstruct{
char*ch;
intlength;
}hstring;
输入并建立顺序存储的字符串s
voidcreatstring（hstring&s）
{if（s.ch）free（s.ch）;
inti;
printf（"输入你要构造的串的元素个数：
\n"）;
scanf（"%d",&i）;
if（!
（s.ch=（char*）malloc（i*sizeof（char））））exit（overflow）;
printf（"请依次输入元素：
\n"）;
getchar（）;
intj;
for（j=0;jscanf（"%c",&s.ch[j]）;
}
求s串从pos开始长度为len的子串放入t串
voidsubstring（hstring&t,hstrings,intpos,intlen）
{
if（pos<1）||pos>s.length||len<0||len>s.length-pos+1）
returnerror;
if（t.ch）free（t.ch）;
if（!
len）{t.ch=null;t.length=0）;}
else{
t.ch=（char*）malloc（len*sizeof（char））;
inti;
for（i=0；i{t.ch[i]=s.ch[pos+i-1];}
t.length=len;
}
returnok;
}
在串s的第i个字符前插入串t
升级会员 