数据结构实验最全顺序表的操作及其应用.docx
《数据结构实验最全顺序表的操作及其应用.docx》由会员分享，可在线阅读，更多相关《数据结构实验最全顺序表的操作及其应用.docx（48页珍藏版）》请在冰豆网上搜索。
数据结构实验最全顺序表的操作及其应用
实验1顺序表的操作及其应用
一、实验目的
1）掌握线性表的顺序存储结构；
2）熟练掌握顺序表基本算法的实现；
3）掌握利用线性表数据结构解决实际问题的方法和基本技巧；
4）按照实验题目要求独立正确地完成实验内容
二、实验内容
要求：
数据元素类型ElemType取整型int或者char。
顺序存储实现如下算法：
1）创建一顺序表；
2）输出该顺序表；
3）在顺序表中查找第i个元素，并返回其值；
4）在顺序表中第i个元素之前插入一已知元素；
5）在顺序表中删除第i个元素；
6）实现顺序表的合并。
（选做）
源程序：
//ASequentialList顺序表
#include
#include
#include
#include
#include
#include
#defineInitSize100//线性表存储空间的初始分配量
#defineListIncrement10//线性表存储空间的分配增量
typedefintElemType;
typedefstruct
{
ElemType*elem;
intlength;
intlistsize;
}SqList;
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
typedefintStatus;
StatusInitList（SqList&L）//初始化
{
L.elem=（ElemType*）malloc（InitSize*sizeof（ElemType））;
if（!
L.elem）
exit（OVERFLOW）;
L.length=0;
L.listsize=InitSize;
returnOK;
}
//求表长
intListLength（SqList&L）
{
returnL.length;
}
//输入元素
intDataInput（SqList&L）
{
inti=1,j=1;
printf（"输入数据后，按“0”结束输入\n"）;
while（j）
{
scanf（"%d",&j）;
if（j!
=0）
{
L.elem[i]=j;
L.length++;
i++;
if（i>InitSize）
break;
}
}
returnFALSE;
}
//输出顺序表
StatusListTraverse（SqListL）
{
ElemType*p;
inti;
p=L.elem;
for（i=0;iprintf（"%d",*p++）;
printf（"\n"）;
returnOK;
}
//查找元素
StatusGetElem（SqListL,inti,ElemType&e）
{
if（i<1||i>L.length）
exit（ERROR）;
e=L.elem[i-1];
returnOK;
}
//插入元素
StatusListInsert（SqList&L,inti,ElemTypee）
{
ElemType*newbase,*q,*p;
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）
exit（OVERFLOW）;
L.elem=newbase;
L.listsize=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;
}
//删除元素
StatusListDeletSq（SqList&L,inti,ElemType&e）
{
ElemType*p,*q;
if（i<1||i>L.length）
returnERROR;
p=&（L.elem[i-1]）;
e=*p;
q=L.elem+L.length-1;
for（++p;p<=q;++p）
*（p-1）=*p;
--L.length;
returnOK;
}
//主函数
intmain（）
{
SqListL;
ElemTypee;
charch;
intt;
while
（1）
{
system（"cls"）;
printf（"\t------------MENU------------------\n"）;
printf（"\t|1.创建一顺序表|\n"）;
printf（"\t|2.输入数据|\n"）;
printf（"\t|3.输出顺序表|\n"）;
printf（"\t|4.查找表中元素|\n"）;
printf（"\t|5.于表中插入元素|\n"）;
printf（"\t|6.删除表中元素|\n"）;
printf（"\t|7.退出|\n"）;
printf（"\t|---------------------------------\n"）;
fflush（stdin）;
ch=getchar（）;
if（ch=='7'）
break;
switch（ch）
{
case'1':
InitList（L）;
printf（"初始化顺序表成功！
\n"）;
printf（"按任何键继续操作···\n"）;
getch（）;
break;
case'2':
DataInput（L）;
printf（"数据输入成功！
\n"）;
printf（"按任何键继续操作···\n"）;
getch（）;
break;
case'3':
ListTraverse（L）;
getch（）;
break;
case'4':
printf（"你查找是第几个元素：
"）;
fflush（stdin）;
scanf（"%d",&t）;
GetElem（L,t,e）;
printf（"你查找的元素是：
%d\n",e）;
printf（"按任何键继续操作···\n"）;
getch（）;
break;
case'5':
printf（"输入你要插入的元素：
"）;
scanf（"%d",&e）;
ListInsert（L,t,e）;
printf（"成功插入！
\n"）;
printf（"按任何键继续操作···\n"）;
getch（）;
break;
case'6':
printf（"你想删除第几个数据：
"）;
scanf（"%d",&t）;
ListDeletSq（L,t,e）;
printf（"成功删除！
\n"）;
printf（"按任何键继续操作···\n"）;
getch（）;
break;
default:
break;
}
}
returnFALSE;
}
运行截图：
主菜单：
1.创建顺序表;
2.输入数据:
3.插入数据：
三、实验总结：
问题:
1.刚开始接触数据结构时，完全不知道这门课程是学什么的，一脸茫然，通过反复看书，最后逐渐明白了其中的含义。
2.有些c语言的函数和c++语言函数不同。
3.函数和指针的知识还不够好，不够牢固。
心得体会；
数据结构是一门重要的课程，万事开头难，刚开始学的时候是很难的，需要自己反复地思考和阅览书籍，才能解开一个个矛盾。
C语言是很基础的，数据结构要想学好，c语言的最基本，特别是要学好里面的函数和指针知识，因为数据结构里面很多都是用到指针和函数的。
实验二链表的操作及其应用
一、实验目的
了解单链表的基本概念、结构的定义及在单链表上的基本操作（插入、删除、查找以及线性表合并），通过在TurboC实现以上操作更好的了解书本上的内容并体会线性表的两种存储结构的区别。
二、实验内容
⑴单链表的插入算法
⑵单链表的删除算法
⑶循环链表的插入和删除算法（选做）
源程序：
#include
#include
#include
#include
typedefintElemType;
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineOVERFLOW-2
typedefintStatus;
typedefstructLNode
{
ElemTypedata;
structLNode*next;
}LNode,*LinkList;
StatusCreateList（LinkList&L,intn）//创建链表
{
L=（LinkList）malloc（sizeof（LNode））;//生成带头结点的链表
LinkListhead,p;
inti;
if（!
L）
{
printf（"创建失败！
"）;
returnFALSE;
}
L->next=NULL;
head=L;
for（i=0;i{
p=（LinkList）malloc（（sizeof（LNode）））;//生成新结点
printf（"请输入结点值：
\n"）;
scanf（"%d",&p->data）;//输入新结点值
p->next=NULL;//尾插法，插入新结点
head->next=p;
head=p;
}
returnTRUE;
}
StatusGetElem_L（LinkListL,inti,ElemType&e）
{
intj=1;
LinkListp;
p=L->next;//使p指向第一个结点
while（p&&j{
p=p->next;//后移
++j;
}
if（!
p||j>i）//第i个元素不存在
{
printf（"取元素失败！
"）;
returnERROR;
}
e=p->data;//取第i个元素
returnOK;
}
StatusListInsert_L（LinkList&L,inti,ElemTypee）//在带头结点的单链表L中的第i个位置之前插入元素e
{
LinkListp,s;
p=L;
intj=0;
while（p&&j{
p=p->next;
++j;
}
if（!
p||j>i-1）
{
printf（"插入失败！
"）;
returnERROR;
}
s=（LinkList）malloc（sizeof（LNode））;//生成新结点指向要插入的元素
s->data=e;
s->next=p->next;
p->next=s;
returnOK;
}
StatusListDelete_L（LinkListL,inti,ElemType&e）//在带头结点的单链表L中，删除第i个元素，并由e返回其值
{
LinkListp,q;
intj=0;
p=L;
while（p->next&&j{
p=p->next;
++j;
}
if（!
p||j>i-1）
{
printf（"删除元素失败！
"）;
returnERROR;
}//删除位置不合理
q=p->next;//删除并释放结点
p->next=q->next;
e=q->data;
free（q）;
returnOK;
}
StatusOutputList（LinkListL）
{
LinkListp;
for（p=L->next;p!
=NULL;p=p->next）
{
printf（"%4d",p->data）;
}
printf（"\n"）;
returnOK;
}
main（）
{
charch;
intn,i;
inte;
LinkListL;
while
（1）
{
system（"cls"）;
printf（"\t\t\t--------MENU--------\n"）;
printf（"\t\t\t|1.创建链表|\n"）;
printf（"\t\t\t|2.输出链表|\n"）;
printf（"\t\t\t|3.插入元素|\n"）;
printf（"\t\t\t|4.删除元素|\n"）;
printf（"\t\t\t|5.退出|\n"）;
printf（"\t\t\t|-------------------|\n"）;
ch=getchar（）;
if（ch=='5'）
break;
switch（ch）
{
case'1':
printf（"请输入你要创建的结点数：
"）;
scanf（"%d",&n）;
printf（"（每输入一个值后按ENTER继续）\n"）;
CreateList（L,n）;
printf（"创建成功！
\n"）;
break;
case'2':
printf（"单链表的值是：
"）;
OutputList（L）;
getch（）;
break;
case'3':
printf（"链表是：
"）;
OutputList（L）;
printf（"请输入你要在第几个元素前插入元素：
"）;
scanf（"%d",&i）;
printf（"请输入你要插入的元素值：
"）;
scanf（"%d",&e）;
ListInsert_L（L,i,e）;
printf（"插入成功！
\n"）;
printf（"新单链表是：
"）;
OutputList（L）;
getch（）;
break;
case'4':
printf（"链表是：
"）;
OutputList（L）;
printf（"你要删除第几个元素：
"）;
scanf（"%d",&i）;
ListDelete_L（L,i,e）;
printf（"删除成功！
\n"）;
printf（"新单链表是：
"）;
OutputList（L）;
getch（）;
break;
default:
break;
}
}
getch（）;
returnOK;
}
运行截图：
主菜单：
1.创建链表：
2.输出链表：
3.插入元素：
4.删除链表：
三、实验总结：
问题：
1.创建链表时，运用前插法，使得最后输出时是反过来输出的；
2.在调用函数ListInsert_L（L,i,e）;时忘记写输入e的语句scanf（"%d",&e）;（就是要插入的元素），使得在最后输出了一个负数或者说是乱码；
解决方法：
1.通过看书和上网学到了尾插法，就是说尾插法的作用是使得最后输出时的数值是按照输入的顺序输出的；
3.第二个问题的解决方法是最后加上了scanf（"%d",&e）;这个语句，这样才不会出现乱码，输出如我所愿；
心得体会：
通过对实验一的学习后，我对数据结构有了更深刻的认识，使得我在做实验的过程中速度加快了很多，掌握了各种函数的应用，能够更深刻地了解单链表的操作及其应用。
实验三栈的操作及其应用
一、实验目的
了解栈的概念、栈的特性、在两种存储结构上如何实现栈的基本操作以及栈在程序设计中的应用。
通过在TurboC中实现顺序栈的插入和删除加深理解顺序栈的意义。
二、实验内容
⑴顺序栈的进栈、出栈算法
⑵链式栈的进栈、出栈算法（选做）
源程序code：
#include
#include
#include
typedefintselemtype;
#definechushi100
#definezengliang10
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineOVERFLOW-2
typedefintStatus;
typedefstruct
{
selemtype*base;
selemtype*top;
intstacksize;
}sqstack;
Statusinitstack（sqstack&s）//初始化栈，构造一个空栈；
{
s.base=（selemtype*）malloc（chushi*sizeof（selemtype））;
if（!
s.base）
{
printf（"存储分配失败\n!
"）;
returnFALSE;
}
s.top=s.base;
s.stacksize=chushi;
returnTRUE;
}
Statusgettop（sqstacks,selemtype&e）//取栈顶元素
{
if（s.top==s.base）
{
printf（"栈为空!
\n"）;
returnFALSE;
}
e=*（s.top-1）;
returnTRUE;
}
Statuspush（sqstack&s,selemtypee）//插入元素进栈
{
if（s.top-s.base>=s.stacksize）//栈满
{
s.base=（selemtype*）realloc（s.base,（s.stacksize+zengliang）*sizeof（selemtype））;
if（!
s.base）
{
printf（"存储分配失败！
"）;
returnFALSE;
}
s.top=s.base+s.stacksize;
s.stacksize+=zengliang;
}
*s.top++=e;
returnTRUE;
}
Statuspop（sqstack&s,selemtype&e）//删除元素出栈
{
if（s.top==s.base）
{
printf（"栈为空！
"）;
returnFALSE;
}
e=*--s.top;
returnTRUE;
}
stacklength（sqstack&s）//初始条件：
栈S已存在操作结果：
返回S的元素个数，即栈的长度
{
returns.top-s.base;
}
Statusoutput_stack（sqstacks）
{
selemtype*p;
inti;
p=s.base;
if（s.top==s.base）
{
printf（"栈不存在!
\n"）;
returnFALSE;
}
for（i=0;i{
printf（"%4d",*p++）;
}
printf（"\n"）;
returnTRUE;
}
Statusclearstack（sqstacks）
{
s.top=s.base;//s.top==s.base作为顺序栈空的标记
returnOK;
}
main（）
{
sqstacks;
charch;
selemtypee;
while
（1）
{
system（"cls"）;
printf（"\t\t\t--------MENUE--------\n"）;
printf（"\t\t\t|1.初始化顺序栈|\n"）;
printf（"\t\t\t|2.输入栈的元素|\n"）;
printf（"\t\t\t|3.输出顺序栈|\n"）;
printf（"\t\t\t|4.进栈|\n"）;
printf（"\t\t\t|5.出栈|\n"）;
printf（"\t\t\t|6.清空顺序栈|\n"）;
printf（"\t\t\t|7.退出|\n"）;
printf（"\t\t\t|--------------------|\n"）;
ch=getchar（）;
if（ch=='7'）
break;
switch（ch）
{
case'1':
initstack（s）;
printf（"初始化成功!
\n"）;
printf（"按任何键继续··"）;
getch（）;
break;
case'2':
printf（"顺序栈是：
"）;
output_stack（s）;
printf（"（请逐个输入数据）\n你要输入的元素是：
"）;
scanf（"%d",&e）;
push（s,e）;
printf（"成功输入数据!
\n"）;
printf（"顺序栈是：
"）;
output_stack（s）;
printf（"按任何键继续··"）;
getch（）;
break;
case'3':
printf（"顺序栈的值是：
"）;
output_stack（s）;
printf（"按任何键继续··"）;
getch（）;
break;
case'4':
printf（"顺序栈的值是：
"）;
output_stack（s）;
printf（"进栈的元素：
"）;
scanf（"%d",&e）;
push（s,e）;
printf（"进栈成功!
\n"）;
printf（"顺序栈的值是：
"）;
output_stack（s）;
printf（"按任何键继续··"）;
getch（）;
break;
case'
升级会员 