实验一 线性表及其应用.docx
《实验一 线性表及其应用.docx》由会员分享，可在线阅读，更多相关《实验一 线性表及其应用.docx（18页珍藏版）》请在冰豆网上搜索。
实验一线性表及其应用
实验一线性表及其应用
09计算机1白杨0929210028
（一）顺序表操作验证
1．问题描述
对以顺序存储结构存储的线性表，验证其插入、删除、查找、就地逆置等操作。
2．基本要求
用菜单实现操作选择。
3．测试数据
自拟。
（三）单链表操作验证
1．问题描述
对以链式存储结构存储的线性表，验证其插入、删除、查找、求长度和就地逆置等操作。
2．基本要求
用菜单实现操作选择。
3．测试数据
自拟。
说明：
选做实验内容详见实验手册
/*顺序表操作验证*/
#include
#include
#include
#include
typedefstruct
{
int*elem;
intlength;
intlistsize;
}SqList;
//初始化顺序表
intInit（SqList&L）
{
L.elem=（int*）malloc（100*sizeof（int））;
if（!
L.elem）
return0;
L.length=0;
L.listsize=100;
return1;
}
//清空顺序表
voidClear（SqList&L）
{
free（L.elem）;
L.elem=NULL;
L.length=0;
}
//在第i个位置上插入一个元素
intInsert（SqList&L,inti,inte）
{
intj,*newbase;
if（i<1||i>L.length+1）return0;
if（L.length>=L.listsize）
{
newbase=（int*）realloc（L.elem,（L.listsize+1）*sizeof（int））;
if（!
newbase）
return0;
L.elem=newbase;
L.listsize++;
}
for（j=L.length;j>=i;--j）
{
L.elem[j]=L.elem[j-1];
}
L.elem[j]=e;
L.length++;
return1;
}
//返回元素e在顺序表中的位置
intLocate（SqListL,inte）
{
inti=1;
int*p;
p=L.elem;
while（i<=L.length&&!
（*p==e））
{
i++;
p++;
}
if（i<=L.length）returni;
return0;
}
//删除第i个位置上的元素
intDelete（SqList&L,inti,int&e）
{
intj;
if（i<1||i>L.length）return0;
e=L.elem[i-1];
for（j=i;j L.elem[j-1]=L.elem[j];
L.length--;
return1;
}
//就地逆置
voidReverse（SqList&L）
{
inti,tmp;
for（i=0;i {
tmp=L.elem[i];
L.elem[i]=L.elem[L.length-i-1];
L.elem[L.length-i-1]=tmp;
}
}
//输出顺序表
voidPrint（SqListL）
{
inti;
printf（"%d\n",L.length）;
for（i=0;i printf（"%d",L.elem[i]）;
printf（"\n"）;
}
//菜单函数
intmenu（void）
{
intnum;
//clrscr（）;
printf（"\n\n"）;
printf（" MENU \n"）;
printf（" ===========================\n"）;
printf（" Sq-listoperation\n"）;
printf（" 1.print\n"）;
printf（" 2.insert\n"）;
printf（" 3.delete\n"）;
printf（" 4.Locate\n"）;
printf（" 5.clear\n"）;
printf（" 6.init\n"）;
printf（" 7.reverse\n"）;
printf（" 0.exit \n"）;
printf（" ===========================\n"）;
printf（" Choice（0,1,2,3,4,5,6,7）:
"）;
scanf（"%d",&num）;
returnnum;
}
intmain（）
{
intInit（SqList&L）; //初始化顺序表
voidClear（SqList&L）; //清空顺序表
intInsert（SqList&L,inti,inte）; //在第i个位置上插入一个元素
intLocate（SqListL,inte）; //返回元素e在顺序表中的位置
intDelete（SqList&L,inti,int&e）;//删除第i个位置上的元素
voidPrint（SqListL）; //输出顺序表
voidReverse（SqList&L）; //就地逆置
intmenu（void）; //菜单函数
intn,i,e,k;
SqListL;
Init（L）;
boolflag=1;
//clrscr（）;
do{
intnum=menu（）;
switch（num）
{
case1:
Print（L）;
break;
case2:
printf（"Inputnumberstocreatlist（endby=0）:
"）;
scanf（"%d",&n）;
while（n--）
{
printf（"inputlocationtoinsertbefore.i="）;
scanf（"%d",&i）;
printf（"inputanumbertoinsert.e="）;
scanf（"%d",&e）;
if（!
Insert（L,i,e））
{
printf（"Insertlocationisnotcorrect!
\n"）;
n++;
printf（"Pleaseinputlocationtoinsertagain.\n"）;
}
}
break;
case3:
printf（"inputalocationtodelete.i="）;
scanf（"%d",&i）;
k=Delete（L,i,e）;
if（!
k）
printf（"Deletelocationisnotexit!
\n"）;
else
printf（"Deletedatais%d.\n",e）;
break;
case4:
printf（"inputanumbertolocate.e="）;
scanf（"%d",&e）;
k=Locate（L,e）;
if（!
k）
printf（"Data%dlocationisnotexit!
\n",e）;
elseprintf（"Thelocationof%dis:
%d.",e,k）;
break;
case5:
Clear（L）;
Init（L）;
break;
case6:
Init（L）;
break;
case7:
Reverse（L）;
break;
case0:
flag=0;
}
}while（flag==1）;
return0;
}
/*测试数据
6
2
4
5
3
1
1
2
3
3
4
4
5
1
4
2
4
3
2
1
2
2
1
7
1
5
0
*/
/*单链表操作验证*/
#include
#include
#include
#include
typedefstructNode
{
intdata;//数据域
Node*next;//指针域
}List;
//初始化链表运算
voidInit（List*&T）//*&T可以改变主函数中T的值
{
T=（List*）malloc（sizeof（List））;//创建头结点*T
T->next=NULL;
}
//头插法建表
voidCreate_head（List*&T,intn）
{
List*s;
inti;
for（i=0;i {
s=（List*）malloc（sizeof（List））;
scanf（"%d",&s->data）;
s->next=T->next;//让节点始终指向第一个节点（head紧接着的那个节点）
T->next=s;//然后断开原先的头节点和第一个节点并头节点指向新的节点s，如此反复
}
}
//尾插法建表
voidCreate_tail（List*&T,intn）
{
List*s,*r;
inti;
r=T;//r始终指向尾结点，开始时指向头结点
for（i=0;i {
s=（List*）malloc（sizeof（List））;
scanf（"%d",&s->data）;
r->next=s;//将*s插入*r之后
r=s;
}
r->next=NULL;//尾结点next域置为NULL
}
//链表长度运算
intLength（List*T）
{
intlen=0;
List*p=T->next;
while（p!
=NULL）
{
p=p->next;
len++;
}
returnlen;
}
//求链表第i个元素运算
intGetelm（List*T,inti,int&e）//&e表示不需要返回e的值，直接在调用函数里改变其值
{
intj=1;
List*p=T->next;
if（i<1||i>Length（T））return0;//i参数不正确，返回0
while（j {
p=p->next;
j++;
}
e=p->data;
return1;
}
//按值查找运算
intLocate（List*T,intx）
{
inti=1;
List*p=T->next;
while（p!
=NULL&&p->data!
=x）//从第1个结点开始查找data域为x的结点
{
p=p->next;
i++;
}
if（p==NULL）return0;
elsereturni;
}
//插入结点运算
intInsert（List*&T,intx,inti）
{
intj=1;
List*p=T,*s;
s=（List*）malloc（sizeof（List））;//创建data域为x的结点
s->data=x;
s->next=NULL;
if（i<1||i>Length（T）+1）return0;//i参数不正确，插入失败，返回0
while（j {
p=p->next;//从头结点开始找，查找第i-1个结点，由p指向它
j++;
}
s->next=p->next;//将*p0的next域指向*p的下一个结点（即第i个结点）
p->next=s;//将*p的next域指向*p0，这样*p0变成第i个结点
return1;//插入运算成功，返回1
}
//删除结点运算
intDelet（List*&T,inti,int&e）
{
intj=1;
List*p=T,*s;
s=（List*）malloc（sizeof（List））;
if（i<1||i>Length（T））return0;//i参数不正确
while（j {
p=p->next;
j++;
}
s=p->next;//由p0指向第i个结点
e=s->data;
p->next=s->next;//将*p的next域指向*p0之后结点，即从链表中删除第i个结点
free（s）;//释放第i个结点占用的空间
return1;
}
//就地逆置
voidReverse（List*&T）
{
List*p,*q;
p=T->next;
if（p&&p->next）//当链表不是空表或单结点时
{
q=p->next;
p->next=NULL;//将开始结点变成终端结点
while（q）
{
p=q;
q=q->next;
p->next=T->next;
T->next=p;
}
T->next=p;
}
}
//合并两个链表
List*Connect（List*la,List*lb）
{
List*pa=la->next;
List*pb=lb->next;
List*lc;
List*pc=lc=la;//把A的头结点作为C的头结点
while（pa&&pb）
{
if（pa->datadata）
{
pc->next=pa;
pc=pa;
pa=pa->next;
}
else
{
pc->next=pb;
pc=pb;
pb=pb->next;
//pa=pa->next;删除重复的
}
}
pc->next=pa?
pa:
pb;
free（lb）;
returnlc;
}
//输出链表运算
voidPrint（List*T）
{
List*p;
for（p=T->next;p->next!
=NULL;p=p->next）
printf（"%d",p->data）;
printf（"%d\n",p->data）;
}
//菜单
intmenu（）
{
intnum;
//clrscr（）;
printf（"\n\n"）;
printf（" MENU \n"）;
printf（" ===========================\n"）;
printf（" Link-listoperation\n"）;
printf（" 1.creat_tail\n"）;
printf（" 2.insert\n"）;
printf（" 3.delete\n"）;
printf（" 4.print\n"）;
printf（" 5.getelement\n"）;
printf（" 6.length\n"）;
printf（" 7.reverse\n"）;
printf（" 8.connect\n"）;
printf（" 9.creat_head\n"）;
printf（" 0.exit\n"）;
printf（" ===========================\n"）;
printf（" Choice（0,1,2,3,4,5,6,7,8,9）:
"）;
scanf（"%d",&num）;
returnnum;
}
intmain（）
{
//freopen（"d:
//data.in","r",stdin）;
//freopen（"d:
//data.out","w",stdout）;
voidInit（List*&T）; //初始化链表运算
voidCreate_head（List*&T,intn）; //头插法建表
voidCreate_tail（List*&T,intn）; //尾插法建表
intLength（List*T）; //链表长度运算
intGetelm（List*T,inti,int&e）; //求链表第i个元素运算
intLocate（List*T,intx）; //按值查找运算
intInsert（List*&T,intx,inti）; //插入结点运算
intDelet（List*&T,inti,int&e）; //删除第i个结点运算
voidReverse（List*&T）; //就地逆置
List*Connect（List*T1,List*T2）; //合并两个链表（两个有序合并成一个有序）
voidPrint（List*T）; //输出链表运算
intmenu（void）; //菜单函数
List*head,*la,*lb;
inti,k,x,n;
boolflag=1;
do{
intnum=menu（）;
//clrscr（）;//清屏
switch（num）
{
case1:
printf（"Inputnumberstocreat_taillist:
"）;
scanf（"%d",&n）;
Init（head）;
printf（"Inputthe%dDatas:
",n）;
Create_tail（head,n）;
break;
case2:
printf（"inputlocati
升级会员 