60140140袁若飞实验1线性表的基本操作及其应用解析.docx

60140140袁若飞实验1线性表的基本操作及其应用解析.docx

《60140140袁若飞实验1线性表的基本操作及其应用解析.docx》由会员分享，可在线阅读，更多相关《60140140袁若飞实验1线性表的基本操作及其应用解析.docx（30页珍藏版）》请在冰豆网上搜索。

60140140袁若飞实验1线性表的基本操作及其应用解析

数据结构

实验1：

线性表的基本操作及其应用

班级：

RB软工移151

学号：

201560140140

姓名：

袁若飞

实验一线性表

一、实验目的

1、帮助读者复习C++语言程序设计中的知识。

2、熟悉线性表的逻辑结构。

3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。

二、实验内容

本次实验提供4个题目，每个题目都标有难度系数，*越多难度越大，题目一、二是必做题。

题目三、题目四选作。

三、实验准备知识

1、请简述线性表的基本特性和线性表的几种基本操作的机制

答：

线性表的基本特性是：

对线性表中某个元素ai来说，称其前面的元素ai-1为ai的直接前驱，称其后前面的元素ai+1为ai的直接后继。

显然，线性表中每个元素最多有一个直接前驱和一个直接后继。

答：

线性表的几种基本操作的机制有六个：

（1）初始化线性表initial_List（L）——建立线性表的初始结构，即建空表。

这也是各种结构都可能要用的运算。

（2）求表长度List_length（L）——即求表中的元素个数。

（3）按序号取元素get_element（L,i）——取出表中序号为i的元素。

（4）按值查询List_locate（L,x）——取出指定值为x的元素，若存在该元素，则返回其地址；否则，返回一个能指示其不存在的地址值或标记。

（5）插入元素List_insert（L,i,x）——在表L的第i个位置上插入值为x的元素。

显然，若表中的元素个数为n，则插入序号i应满足1<=i<=n+1。

（6）删除元素List_delete（L，i）——删除表L中序号为i的元素，显然，待删除元素的序号应满足1<=i<=n。

2、掌握线性表的逻辑结构。

3、掌握线性表的链式存储结构。

4、熟练掌握线性表的插入、删除等操作。

四、实验内容

题目一：

顺序表的基本操作

[问题描述]

实现顺序表的建立、求长度，取元素、修改元素、插入、删除等基本操作。

[基本要求]

（1）依次从键盘读入数据，建立顺序表；

（2）输出顺序表中的数据元素；

（3）求顺序表的长度；

（4）根据指定条件能够取元素和修改元素；

（5）实现在指定位置插入和删除元素的功能。

[测试数据]

由学生任意指定。

运行结果如下图：

1）实现删除功能

2）实现取元素功能

3）实现查找功能

4）实现插入功能

[源代码]（加注释）

#include

#include

#include

#definemaxlen100//设元素个数最大为100

typedefstruct//声明一个结构体来存放顺序表

{intdata[maxlen];//定义存储表中元素的数组

intlistlen;//定义表长度分量

}seqlist;

voidget_element（seqlist*L,intI,int*x）;//按序号求元素运算的子函数

intList_locate（seqlistL,intI,intx）;//声明按值查询元素的子函数

boolList_insert（seqlist*L,intI,intx）;//声明插入元素的子函数

boolList_delete（seqlist*L,intI）;//声明删除元素的子函数

voidmain（）

{seqlist*L;//表结构变量的定义

L=（seqlist*）malloc（sizeof（seqlist））;//为表分配空间

inti;//定义整型变量

for（i=1;i<=20;i++）//赋值给表中的元素

{L->data[i-1]=i;//填入删除内容

}

L->listlen=20;//定义表的长度

cout<<"删除前的顺序表:

\n";

for（i=1;i<=L->listlen;i++）//输出表中元素

{cout<data[i-1]<<"";

}

cout<<"\n输入要删除的纪录号:

";

cin>>i;//用户输入删除的记录

if（List_delete（L,i））//用删除元素的子函数

{cout<<"\n删除成功！

删除后的顺序表为:

\n";

for（i=1;i<=L->listlen;i++）//向前批量移动元素

{cout<data[i-1]<<"";

}

}

}

boolList_delete（seqlist*L,inti）//删除元素的子函数

{intj;//定义一个整型变量

if（L->listlen<=0）//空表不能删除元素

{cout<<"下溢出错！

";

returnfalse;//返回false

}

if（i>L->listlen||i<=0）//删除元素不存在

{cout<<"删除位置错！

";

returnfalse;//返回false

}

else{for（j=i;j<=L->listlen-1;j++）//向前批量移动元素

{L->data[j-1]=L->data[j];;

}

L->listlen--;//表长度减1

returntrue;//返回true

}

}

voidmain（）

{seqlist*L;//表结构变量的定义

L=（seqlist*）malloc（sizeof（seqlist））;//为表分配空间

inti;//定义整型变量

for（i=1;i<=20;i++）//赋值给表中的元素

{L->data[i-1]=i;

}

L->listlen=20;//定义表的长度

cout<<"取元素前的顺序表:

\n";

for（i=1;i<=L->listlen;i++）//输出表中元素

{cout<data[i-1]<<"";

}

cout<<"\n输入要取元素的序号:

";

cin>>i;//用户输入要取元素的记录

if（get_element（L,i））//用取元素的子函数

{cout<<"\n取元素成功！

取元素后的顺序表为:

\n";

for（i=1;i<=L->listlen;i++）

{cout<data[i-1]<<"";

}

}

}

boolget_element（seqlist*L,inti）//取元素的子函数

{intx;

if（i<1||i>L->listlen）//要取的元素不存在

{cout<<"下溢出错！

";//空表无元素

returnfalse;}

else

{x=L->data[i-1];//取出相应元素

cout<<"\n所取的元素\n";

cout<

returntrue;}

}

voidmain（）

{seqlist*L;//表结构变量的定义

L=（seqlist*）malloc（sizeof（seqlist））;//为表分配空间

inti,x,a;//定义三个整型变量

for（i=1;i<=20;i++）//赋值给表中的元素

{L->data[i-1]=i;

}

L->listlen=20;//定义表的长度

cout<<"查找元素前的顺序表:

\n";

for（i=1;i<=L->listlen;i++）//输出表中元素

{cout<data[i-1]<<"";

}

cout<<"\n输入要查元素:

";

cin>>x;//用户输入查找的记录

a=List_locate（L,x）;

if（a!

=0）

{cout<<"\n查元素成功！

查元素后的顺序表为:

\n";

cout<

cout<<"\n取元素后的顺序表为:

\n";//取元素后的顺序

for（i=1;i<=L->listlen;i++）//输出表中元素

{cout<data[i-1]<<"";

}

}

elsecout<<"\n查无此元素成功！

:

\n";

}

intList_locate（seqlist*L,intx）//按值查询元素的子函数

{inti;//定义一个整型变量

for（i=0;ilistlen;i++）//依次比较各个元素

{if（L->data[i]==x）return（i+1）;//找到元素X的位置返回其序号

}

return（0）;//未找到则返回0值

}

voidmain（）

{seqlist*L;//表结构变量的定义

L=（seqlist*）malloc（sizeof（seqlist））;//为表分配空间

inti,x,a;//定义三个整型变量

for（i=1;i<=20;i++）//赋值给表中的元素

{L->data[i-1]=i;//填入插入内容

}

L->listlen=20;//定义表的长度

cout<<"插入元素前的顺序表:

\n";

for（i=1;i<=L->listlen;i++）//输出表中元素

{cout<data[i-1]<<"";

}

cout<<"\n输入要插的元素:

";

cin>>x;//用户输入插入的记录

cout<<"\n输入要插的位置:

";

cin>>i;//用户输入插入的位置

a=List_insert（L,i,x）;

if（a==1）

{cout<<"\n插入元素成功！

:

\n";

cout<<"\n插入元素后的顺序表为:

\n";

for（i=1;i<=L->listlen;i++）//输出表中元素

{cout<data[i-1]<<"";

}

}

elseif（a==0）

cout<<"溢出,不能插入！

";//溢出,不能插入

elsecout<<"插入位置错！

";

}

intList_insert（seqlist*L,inti,intx）//插入元素的子函数

{intj;//定义一个整型变量

if（L->listlen==maxlen）

{cout<<"溢出,不能插入！

";//溢出，不能插入

return0;//返回

}

elseif（i<1||i>L->listlen+1）

{cout<<"插入位置错！

";//插入范围错

return-1;}//返回并结束

else

{for（j=L->listlen-1;j>=i-1;j--）//往后移动元素

L->data[j+1]=L->data[j];

L->data[i-1]=x;//填入插入的元素

L->listlen++;//修改表长度

return1;//返回

}

}

题目二：

单链表的基本操作

[问题描述]

实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。

[基本要求]

（1）依次从键盘读入数据，建立带头结点的单链表；

（2）输出单链表中的数据元素

（3）求单链表的长度；

（4）根据指定条件能够取元素和修改元素；

（5）实现在指定位置插入和删除元素的功能。

[测试数据]

由学生任意指定。

创建单链表读入数据：

1234542

输出单链表中数据为：

1234542

返回单链表长度：

7

在5前面插入数据元素：

12344542

删除第一个数据元素：

234542

修改最后一个数据元素：

1234541

设计分析：

从上面的问题描述可以知道我们要实现的操作：

“依次从键盘读入数据，建立带头结点的单链表，然后就是对此单链表的一些基本操作如增删改查等”，对此我们设计出了一个单链表用于存放数据，所以对数据应该采用的是链式存储结构。

每个元素之间的关系，可通过在每个节点当中设置一个指针来存放下一个元素的地址来体现。

其次就是基本操作就是对此单链表中数据存储结构的更改，通过调用链表指针操作其存储地址。

于是可以声明结构类型为：

typedefstructLNode{

ElemTypedata;

structLNode*next;

}LNode,*LinkList;

1.先动态创建一个单向循环链表，每个节点包含数据的地址和指向下一个节点的地址。

2.查找单链表的头节点并返回其地址，依次从键盘输入数据并把它们的地址返回。

3.根据单链表的头结点的地址依次输出单链表中数据元素，并返回单链表的长度。

4.从单链表中删除出数据元素的节点，并返回新的单向循环链表的头指针的值。

5.利用预定义的指针指向指定位置插入或删除单链表中的数据元素。

运行结果如下图：

1）实现建立单链表功能

2）实现输出功能

3）实现链表长度功能

4）实现取元素功能

5）实现修改功能

[源代码]（加注释）

#include

#include

#defineList_Init_Size100

#defineListIncrement10

#defineElemTypeint

#definenull0

typedefstructLNode{

ElemTypedata;

structLNode*next;

}LNode,*LinkList;

voidmain（）{

voidCreate（LinkList&L）;

voidInsert（LinkList&L,inti,ElemTypee）;

voidDelete（LinkList&L,inti）;

ElemTypeGetElem（LinkList&L,inti）;

voidOutput（LinkList&L）;

intGetLength（LinkList&L）;

voidModify（LinkList&L,inti,ElemTypeelem）;

LinkListl;

intchoose,location,value,times=0,createTimes=0,insertTimes=0;

printf（"请选择你要执行的操作对应的数字：

\n0-退出，1-创建，2-添加，3-删除，4-读元素，5-遍历，6-获取长度，7-修改\n"）;

printf（"你必须先创建单链表\n"）;

scanf（"%d",&choose）;

while（choose!

=0）{

if（choose==1）

Create（l）;

elseif（choose==2）{

printf（"请输入你要添加元素的位置和值，中间用空格隔开。

例如：

12\n"）;

if（insertTimes==0）{

printf（"切记：

位置必须为1\n"）;

insertTimes++;

}

else

printf（"切记：

位置要大于0，并且小于%d\n",GetLength（l））;

scanf（"%d%d",&location,&value）;

Insert（l,location,value）;

}

elseif（choose==3）{

printf（"请输入你要删除元素的位置：

\n"）;

printf（"切记：

位置要大于0，并且小于%d\n",GetLength（l））;

scanf（"%d",&location）;

Delete（l,location）;

}

elseif（choose==4）{

printf（"请输入你要读的数据的位置：

\n"）;

printf（"切记：

位置要大于0，并且小于%d\n",GetLength（l））;

scanf（"%d",&location）;

printf（"%d\n",GetElem（l,location））;

}

elseif（choose==5）

Output（l）;

elseif（choose==6）

printf（"%d\n",GetLength（l））;

else{

printf（"请输入你要修改元素的位置和修改后的值，中间用空格隔开。

例如：

12\n"）;

printf（"切记：

位置要大于0，并且小于%d\n",GetLength（l））;

ElemTypee1=0;

scanf（"%d%d",location,e1）;

Modify（l,location,e1）;

}

++times;

if（times%10==0）{

printf（"请选择你要执行的操作对应的数字：

\n0-退出，1-创建，2-添加，3-删除，4-读元素，5-遍历，6-获取长度\n"）;

printf（"请确认你已经创建单链表，如果没有的话，请首先创建！

"）;

}

scanf（"%d",&choose）;

}

}

voidCreate（LinkList&L）{

L=（LinkList）malloc（sizeof（LNode））;//建立带头节点的单链表

L->next=null;

printf（"单链表创建成功！

\n"）;

}

voidInsert（LinkList&L,inti,ElemTypee）{//在第i个位置插入元素

LinkListp,s;

p=L;

intj=0;

while（p&&j

p=p->next;//获得位置i处的指针

++j;

printf（"元素插入成功！

\n"）;

}

if（p&&（j==i-1））{

s=（LinkList）malloc（sizeof（LNode））;

s->data=e;

s->next=p->next;

p->next=s;

printf（"元素插入成功！

\n"）;

}

}

voidDelete（LinkList&L,inti）{

LinkListp=L,p1=p->next;

intj=0;

if（p->next&&i>0）{

while（p1&&j

p=p1;

p1=p->next;

++j;

}

if（j==i-1）{

p->next=p1->next;

printf（"元素删除成功！

\n"）;

}

}

else

printf（"元素删除失败，因为你输入的位置小于1！

\n"）;

}

ElemTypeGetElem（LinkList&L,inti）{

LinkListp=L->next;

intj=1;

ElemTypee;

while（p&&j

p=p->next;

++j;

}

if（p&&（j==i））{//此单链表有头指针，索引和下标一致

e=p->data;

printf（"成功获取元素！

"）;

}

returne;

}

voidOutput（LinkList&L）{

LinkListp=L->next;

printf（"单链表中的元素分别为：

"）;

while（p）{

printf（"%d",p->data）;

p=p->next;

}

printf（"\n"）;

}

intGetLength（LinkList&L）{

LinkListp=L;

intj=0;

while（p）{

p=p->next;

++j;

}

returnj;

}

voidModify（LinkList&L,inti,ElemTypeelem）{

LinkListp=L->next;

intj=1;

ElemTypee;

while（p&&j

p=p->next;

++j;

}

if（p&&（j==i））{//此单链表有头指针，索引和下标一致

p->data=elem;

printf（"修改元素成功！

\n"）;

}

else

printf（"修改元素失败!

\n"）;

}

题目三：

约瑟夫环（**）

[问题描述]

　　约瑟夫（Joseph）问题的一种描述是：

编号为1,2,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。

一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。

报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。

试设计一个程序求出出列顺序。

[基本要求]

　　利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。

[测试数据]

由学生任意指定。

如：

m的初值为20；n的值为7；密码：

3，1，7，2，4，8，4；

（正确的输出结果应为6，1，4，7，2，3，5）。

（报告上要求写出多批数据测试结果）

[实现提示]

程序运行后首先要求用户输入初始报数上限值m，人数n,（设n≤30）。

然后输入各人的密码。

[选作内容]

　　向上述程序中添加在顺序结构上实现的部分。

运行结果如下图：

约瑟夫环实现功能

[源代码]（加注释）

#include

#include

#include

typedefstructnode

{intnumber;

intpassword;

structnode*next;

}Node,*Linklist;

LinklistCreateLinklist（intamount）

{inti;

Node*s=NULL,*r=NULL;

LinklistL=NULL,R=NULL;

for（i=0;i

{

s=（Node*）malloc（sizeof（Node））;

if（s==NULL）

{printf（"空间申请失败!

"）;

exit（0）;

}

s->number=i+1;

s->password=rand（）%10+1;

printf（"%4d的密码%4d\n",s->number,s->password）;

if（i==0）

{L=s;r=s;}

else{r->next=s;

r=s;}}

R=r;

r->next