实验一线性表操作.docx
《实验一线性表操作.docx》由会员分享，可在线阅读，更多相关《实验一线性表操作.docx（34页珍藏版）》请在冰豆网上搜索。
实验一线性表操作
实验一、线性表操作
一、实验目的
1．掌握用程序设计语言调试程序的基本方法。
2．掌握线性表的基本运算，如插入、删除等。
二、实验内容
1．顺序表、线性链表的插入、删除、合并等操作；
2．利用单向链表作为存储结构，实现一元稀疏多项式的加、减运算。
三、实验性质
设计性实验。
四、实验要求
1．C++/C完成算法设计和程序设计并上机调试通过。
2．撰写实验报告，提供实验结果和数据。
3．分析算法，要求给出具体的算法分析结果，并简要给出算法设计小结和心得。
五、程序实现
写出每个操作的算法（操作过程）。
六、程序运行情况
写出输入数据及运行结果。
七、撰写、提交实验报告及源程序清单。
顺序表的插入、删除、合并等操作
#include
#include
#include
#include
usingnamespacestd;
#defineOK1
#defineERROR0
#defineOVERFLOW-1
#defineLIST_INIT_SIZE100//初始容量
#defineLISTINCREMENT10//空间增量
typedefintstatus;
typedefintElemType;
typedefstructSqList
{
ElemType*elem;//存储空间基址
intlength;//表长,元素个数
intlistsize;//表容量,空间大小
}SqList;
statusInitlist_sq（SqList&L）//进行初始化
{
L.elem=（ElemType*）malloc（（LIST_INIT_SIZE）*sizeof（ElemType））;
if（!
L.elem）
returnOVERFLOW;
L.length=0;//置空表为0，即此时元素的个数为0
L.listsize=100;//表的容量为100，即可以添加100个元素
returnOK;
}
statusInitlist_inputsq（SqList&L,intn）//初始化顺序表的元素
{
intcin;
if（n<=0）
returnERROR;
if（n>L.listsize）
{
ElemType*newbase=（ElemType*）realloc
（L.elem,（L.listsize+LISTINCREMENT）*sizeof（ElemType））;
if（!
newbase）exit（OVERFLOW）;
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
printf（"请输入%d个整型数值:
\n",n）;
for（inti=0;i{
scanf（"%d",&cin）;//读入要输入的数字
L.elem[i]=cin;
}
L.length=n;
returnOK;
}
statusInsertlist_sq（SqList&L,inti,ElemTypee）
//插入的操作应该是插入到顺序表中已经有的元素，即L.length个元素之中，
{//其有效的插入范围是1到L.length+1，而不是L.listsize中的任意位置
if（i<0||i>L.length+1）
returnERROR;
if（L.length>L.listsize）
{
ElemType*newbase=（ElemType*）realloc（L.elem,（L.listsize+LISTINCREMENT）*sizeof（ElemType））;
if（!
newbase）exit（OVERFLOW）;
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
ElemType*CurElem,*InsertElem;
InsertElem=&（L.elem[i-1]）;//插入位置
CurElem=&（L.elem[L.length-1]）;//指向最后
while（CurElem>=InsertElem）
{
*（CurElem+1）=*CurElem;
CurElem--;
}
*InsertElem=e;
++L.length;
returnOK;
}
statusListDlete_sq（SqList&L,inti）
{
if（i<0||i>L.length）
returnERROR;
ElemType*CurElem,*RearElem;
CurElem=&L.elem[i-1];
RearElem=&（L.elem[L.length-1]）;
while（CurElem{
*CurElem=*（CurElem+1）;
++CurElem;
}
--L.length;
returnOK;
}
//取出i位置的元素
statusGetElem_Sq（SqList&L,inti,ElemType&e）
{
if（i<0||i>L.length）
returnERROR;
e=L.elem[i-1];
returnOK;
}
//清空表
statusDestroyList_Sq（SqList&L）
{
inti;
free（L.elem）;
L.elem=NULL;
returnOK;
}
statusListLength_Sq（SqList&L）
{
return（L.length）;
}
voidprint（SqList&L）
{
for（inti=0;iprintf（"%d\n",L.elem[i]）;
}
//先将原来的顺序表排序
statusOrderList_Sq（SqListLa,SqListLb）
{
intm,n;
ElemTypea,b;
for（m=0;mfor（n=m+1;n{
GetElem_Sq（La,m+1,a）;
GetElem_Sq（La,n+1,b）;
if（a>b）
{
La.elem[m]=b;
La.elem[n]=a;
}
}
for（m=0;mfor（n=m+1;n{
GetElem_Sq（Lb,m+1,a）;
GetElem_Sq（Lb,n+1,b）;
if（a>b）
{
Lb.elem[m]=b;
Lb.elem[n]=a;
}
}
returnOK;
}
//合并顺序表
statusMergeList_Sq（SqListLa,SqListLb,SqList&Lc）
{
Initlist_sq（Lc）;
if（!
Lc.elem）
returnOVERFLOW;
inti=1,j=1,k=0;
ElemTypea,b;
while（i<=La.length&&j<=Lb.length）
{
GetElem_Sq（La,i,a）;
GetElem_Sq（Lb,j,b）;
if（a{
Insertlist_sq（Lc,++k,a）;
++i;
}
else
{
Insertlist_sq（Lc,++k,b）;
++j;
}
}
while（i<=La.length）
{
GetElem_Sq（La,i++,a）;
Insertlist_sq（Lc,++k,a）;
}
while（j<=Lb.length）
{
GetElem_Sq（Lb,j++,b）;
Insertlist_sq（Lc,++k,b）;
}
returnOK;
}
intmain（）
{
SqListLa,Lc,Lb;
intn,i;
printf（"下面进行顺序表的初始化、删除、插入、排序、合并：
\n"）;
Initlist_sq（La）;
printf（"请输入要输入的元素的个数:
\n"）;
scanf（"%d",&n）;
Initlist_inputsq（La,n）;
printf（"元素有%d个\n",ListLength_Sq（La））;
printf（"请输入要删除的元素位置:
\n"）;
scanf（"%d",&n）;
ListDlete_sq（La,n）;
printf（"删除后的顺序表为:
\n"）;
print（La）;
printf（"\n"）;
printf（"请分别输入要插入的元素及所插的位置:
\n"）;
scanf（"%d%d",&n,&i）;
Insertlist_sq（La,i,n）;
printf（"插入元素后的顺序表为:
\n"）;
print（La）;
printf（"创建第二个顺序表:
\n"）;
Initlist_sq（Lb）;
printf（"请输入要输入的元素的个数:
\n"）;
scanf（"%d",&n）;
Initlist_inputsq（Lb,n）;
printf（"元素有%d个\n",ListLength_Sq（Lb））;
printf（"将两个顺序表先排序:
\n"）;
OrderList_Sq（La,Lb）;
printf（"La为:
\n"）;
print（La）;
printf（"Lb为:
\n"）;
print（Lb）;
printf（"进行合并操作:
\n"）;
MergeList_Sq（La,Lb,Lc）;
printf（"合并后的顺序表为:
\n"）;
print（Lc）;
printf（"谢谢使用\n"）;
return0;
}
运行结果：
下面进行顺序表的初始化、删除、插入、排序、合并
请输入要输入的元素的个数：
3
请输入3个整形数值
12
23
34
元素有3个
请输入要删除的元素位置:
2
删除后的顺序表为:
12
34
请分别输入要插入的元素及所插的位置:
1
2
插入元素后的顺序表为:
12
1
34
创建第二个顺序表:
请输入要输入的元素的个数:
3
请输入3个整形数值
1
3
2
元素有3个
将两个顺序表先排序:
La为:
1
12
34
Lb为:
1
2
3
进行合并操作:
合并后的顺序表为:
1
1
2
3
12
34
谢谢使用
线性链表的插入、删除、合并等操作
#include
#include
#include"conio.h"
#defineTRUE1
#defineFALSE0
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
typedefintStatus;
typedefstructLNode
{
intdata;
structLNode*next;
}LNode,*LinkList;
//建立一个链表，正序
StatusCreatList（LinkList&L,intn）
{
inti=0;
LinkListp,q;
L=（LinkList）malloc（sizeof（LNode））;
if（L==NULL）returnERROR;
L->next=NULL;
q=L;
while（i{
p=（LinkList）malloc（sizeof（LNode））;//结点增加
printf（"inputdata:
\t"）;
scanf（"%d",&p->data）;//数据域赋值
q->next=p;//指向下一结点
q=p;
i++;
}
q->next=NULL;
returnOK;
}
StatusListInsert_L（LinkList&L,inti,inte）//在带头结点的单链表性表L中第i个位置之前插入元素e
{
LinkListp,s;
intj;
p=L;
j=0;
while（p&&j{
p=p->next;
++j;
}
if（!
p||j>i-1）//i小于1或大于表长
{
returnERROR;
}
s=（LinkList）malloc（sizeof（LNode））;//生成结点
s->data=e;
s->next=p->next;//插入L中
p->next=s;
returnOK;
}
StatusListDelete_L（LinkList&L,inti,int&e）//删除第i个元素
{
intj;
LinkListp,q;
p=L;
j=0;
while（p->next&&j{
p=p->next;
++j;
}
if（!
（p->next）||j>i-1）returnERROR;
q=p->next;
p->next=q->next;//删除时的指针操作
e=q->data;
free（q）;//返回被删元素，释入结点内存
returnOK;
}
StatusGetElem_L（LinkListL,inti,int*e）//获得表中第i个元素值
{
LinkListp;
intj;
p=L->next;
j=1;
while（p&&j{
p=p->next;//依次向后找第i个元素
++j;
}
if（!
p||j>i）returnERROR;//找不到或过大
*e=p->data;
returnOK;
}
voidorder（LinkList&L）
{
//冒泡排序,递增
inttemp;
LinkListOUT,IN;
OUT=L->next;//指向第一个
while（NULL!
=OUT）{//外循环
IN=OUT->next;//指向下一个
while（NULL!
=IN）{//内循环
if（IN->datadata）
{
temp=IN->data;
IN->data=OUT->data;
OUT->data=temp;
}
IN=IN->next;
}
OUT=OUT->next;
}
}
voidMergeList（LinkList&L,LinkList&Ll,LinkList&Lc）
{//L，Ll为递增排序，归并为lc，lc也按递增
LinkListpa,pb,pc;
pa=L->next;
pb=Ll->next;
Lc=pc=L;//用La的头结点作为Lc的头结点
while（pa&&pb）{
if（pa->data<=pb->data）{
pc->next=pa;
pc=pa;
pa=pa->next;
}
else{
pc->next=pb;
pc=pb;
pb=pb->next;
}
}
pc->next=pa?
pa:
pb;
free（Ll）;
}
voidPrintList（LinkListL）//显示表中所有元素
{
LinkListp;
p=L->next;//指向第一个结点
printf（"————————————\n"）;
while（p）
{
printf（"%d\t",p->data）;
p=p->next;
}
printf（"\n"）;
}
voidmain（）
{
inti,n;
inte;
LinkListL,Ll,Lc;
printf（"下面进行线性链表的插入、查找、删除、合并\n"）;
printf（"输入线性表的长度：
\n"）;
scanf（"%d",&n）;
CreatList（L,n）;
PrintList（L）;//显示当前链表内容
printf（"输入插入元素的位置\t"）;
scanf（"%d",&i）;
printf（"输入插入元素\t"）;
scanf（"%d",&e）;
ListInsert_L（L,i,e）;
PrintList（L）;//显示当前链表内容
printf（"查找元素的位置\t"）;
scanf（"%d",&i）;
GetElem_L（L,i,&e）;
printf（"%d\n",e）;
printf（"删除元素的位置\t"）;
scanf（"%d",&i）;
ListDelete_L（L,i,e）;
PrintList（L）;//显示当前链表内容
printf（"新建一个链表，体验合并功能：
\n"）;
printf（"输入线性表的长度：
\n"）;
scanf（"%d",&n）;
CreatList（Ll,n）;
PrintList（Ll）;//显示当前链表内容
printf（"开始合并！
\n"）;
MergeList（L,Ll,Lc）;
order（L）;
printf（"合并结果：
\n"）;
PrintList（L）;//显示当前链表内容
}
运行结果：
下面进行线性链表的插入、查找、删除、合并
输入线性表的长度：
4
Inputdata:
1
Inputdata:
34
Inputdata:
45
Inputdata:
1
————————————
134451
输入插入元素的位置:
1
输入插入元素:
2
————————————
2134451
查找元素的位置1
2
删除元素的位置2
————————————
234451
新建一个链表，体验合并功能：
输入线性表的长度：
3
Inputdata:
12
Inputdata:
13
Inputdata:
4
————————————
12134
开始合并！
合并结果：
————————————
12412133445
Pressanykeytocontinue
利用单向链表作为存储结构，实现一元稀疏多项式的加、减运算。
#include
#include
#include
typedefstruct_POLYNODE{
intcoef;//系数
intexp;//指数
struct_POLYNODE*next;
}polynode,*polyptr;//定义一个节点和一个链表
voidcreatePoly（polynode**P,charch[]）;//建立多项式链表
voidpolyAdd（polynode*A,polynode*B）;//多项式加
voidpolyMinus（polynode*A,polynode*B）;//减
voidorder（polynode**P）;//排序
voiddisplay（polynode*P）;//展示多项式
voiddestroy（polynode**P）;//销毁多项式
voidmenu（）;//命令菜单
intIsChoice（intchoice）;//判断菜单选择
intisPut（charch[]）;
//菜单
voidmenu（）{
printf（"1.输入多项式.\n"
"2.多项式相加.\n"
"3.多项式相减.\n"
"4.显示多项式.\n"
"5.销毁多项式.\n"
"6.退出.\n"）;
}
//判断菜单选择正误
intIsChoice（intchoice）{
if（0choice）
return1;
else
return0;
}
//判断输入是否合格
intisPut（charch[]）
{
inti,j=1;
for（i=0;ch[i]!
='\0';i++）{
if（0==j&&'^'==ch[i]）//只需输入系数与指数与+-*/符号
return0;
if（'^'==ch[i]&&1==j）
j=0;
if（（'+'==ch[i]||'-'==ch[i]||'*'==ch[i]||'/'==ch[i]）&&0==j）
j=1;//若已输入运算符，则标志再要输入系数
if（'.'!
=ch[i]&&'x'!
=ch[i]&&'X'!
=ch[i]&&'^'!
=ch[i]&&'+'!
=ch[i]&&'-'!
=ch[i]&&'*'!
=ch[i]&&'/'!
=ch[i]&&!
isdigit（ch[i]））
return0;
else{
if（'+'==ch[0]||'*'==ch[0]||'/'==ch[0]||'^'==ch[0]||'.'==ch[0]）
return0;
if（'\0'==ch[i+1]&&'+'==ch[0]||'*'==ch[0]||'/'==ch[0]||'^'==ch[0]）
return0;
//上面是判断字符串首尾是否合格下面是中间部分
if（0!
=i&&ch[i+1]!
='\0'）{
if（（'X'==ch[i]||'x'==ch[i]）&&!
isdigit（ch[i-1]）&&'+'!
=ch[i-1]&&'-'!
=ch[i-1]&&'*'!
=ch[i-1
升级会员 