东华大学数据结构上机实验报告

东华大学信息科学与技术学院
实验报告
实验名称：线性表的基本操作
指导教师：
学生姓名：
学生学号：
实验日期：2012/11
一、实验目的
１、熟悉Ｃ或VC++语言上机环境。

２、会定义线性表的顺序存储结构和链式存储结构。

３、熟悉顺序表和单链表的一些基本操作和应用。

４、加深对线性表的理解，逐步培养解决实际问题的编程能力。

二、实验环境
运行Ｃ或VC++的微机。

三、实验内容：分别使用顺序表和单链表存储结构实现以下操作：
1.建立线性表L＝｛12,13,21,24,28,31,42,77｝；
2.在第5个元素之前插入26；
3.删除第5个元素28；
4.查找28。

四、实验设计思路及算法流程
(一)使用顺序表实现操作:
建立顺序表，完成顺序表的基本操作：初始化、插入、删除、输出、查找元素、判线性表是否为空；
问题分析：利用顺序表,设计一组输入数据，能够对顺序表进行如下操作：
创建一个新的顺序表，实现动态空间分配的初始化；
已给定的值插入到指定位置和删除指定位置的值，形成有序顺序表；
按值查找，根据给定数据元素的值，查找该元素的位置，对查找结果进行返回；
实现顺序表的各个元素的输出；
“初始化算法”的操作结果：构造一个空的顺序线性表，对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；
“位置插入算法”的初始条件：顺序线性表L已存在，给定的元素位置为i，且1≤i
≤ListLength(L)+1 ；其操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1；
“位置删除算法”的初始条件：顺序线性表L已存在，1≤i≤ListLength(L) ；其操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 ；
“输出算法”的初始条件：顺序线性表L已存在；其操作结果：依次对L的每个数据元素进行输出；
“按值查找算法”初始条件：顺序线性表L已存在，元素值为e；其操作结果：返回L 中数据元素值为e的元素位置；
线性表的顺序存储结构的定义及其基本操作的参考程序（顺序表）
文件一：pubuse. h 是公共使用的常量定义和系统函数调用声明。

/* 公共使用的常量定义和系统函数调用声明*/
/* (程序名) */
#include<iostream>
using namespace std;
/* 函数结果状态代码*/
#define TRUE 1 //宏定义
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int S tatus; /* S tatus是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int ElemType; //类型定义
文件二：seqlistdef.h 进行线性表的动态分配顺序存储结构的表示。

/* 线性表的动态分配顺序存储结构*/
#define LISTINCREMENT 20 /* 线性表存储空间的分配增量*/
#define LIST_INIT_SIZE 30 /* 线性表存储空间的初始分配量*/
typedef struct {
ElemT ype *elem; /* 存储空间基址*/
int length; /* 当前长度*/
int listsize; /* 当前分配的存储容量(以sizeof(ElemT ype)为单位) */
}SqList;
文件三：seqlistalgo. h 进行线性表顺序存储结构的基本实验算法定义。

/* 顺序表示的线性表的基本操作*/
Status InitList_Sq(SqList &L) /* 思路类似于算法2.3 */
{ /* 操作结果：构造一个空的顺序线性表*/
L.elem=new ElemT ype[LIST_INIT_SIZE]; //
if(!L.elem)
exit(OVERFLOW); /* 存储分配失败*/
L.length =0; /* 空表长度为0 */
L.listsize=LIST_INIT_SIZE; /* 初始存储容量*/
return OK;
}
Status ListInsert(SqList &L,int i,ElemT ype e) /* 思路类似于算法2.4 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */ /* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */ int *q,*p;ElemT ype *newbase; //?
if(i<1 || i>L.length+1) return ERROR; /* i值不合法*/
if(L.length>=L.listsize) /* 当前存储空间已满,增加分配*/
{ newbase=new ElemT ype[L.listsize+LISTINCREMENT];
if(!newbase)
exit(OVERFLOW); /* 存储分配失败*/
L.elem=newbase; /* 新基址*/
L.listsize+=LISTINCREMENT; /* 增加存储容量*/
}
q=&(L.elem[i-1]); /* q为插入位置*/
for (p=&(L.elem[L.length-1]);p>=q;--p) /* 插入位置及之后的元素右移*/ *(p+1)=*p;
*q=e; /* 插入e */
++L.length; /* 表长增1 */
return OK;
}
Status Look(SqList &L,ElemT ype e) /* 思路类似于算法2.4 */
{/* 初始条件：顺序线性表L已存在*/
/* 操作结果：返回L中第1个与e满足相等关系的数据元素的位序。

*/
/* 若这样的数据元素不存在，则返回值为0*/
int *p=L.elem,*q=L.elem+L.length-1; /* p的初值为第1个元素的存储位置*/
int i=1; /* i的初值为第1个元素的位序*/
//记录此时元素在线性表中的次序
for(;p<=q;++p)
{
if(*p==e)
cout<<"该元素在线性表中的位序为："<<i<<" "; //返回元素在线性表中的次序
++i;
}
return OK;
}
Status ListDelete_Sq(SqList &L,int i,ElemT ype &e) /* 思路类似于算法2.5 */
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
ElemT ype *p, *q;
if(i<1 || i>L.length) return ERROR; /* i值不合法*/
p=&(L.elem[i-1]); /* p为被删除元素的位置*/
e=*p; /* 被删除元素的值赋给e */
q=L.elem+L.length-1; /* 表尾元素的位置*/
for(++p;p<=q;++p) /* 被删除元素之后的元素左移*/
*(p-1)=*p;
--L.length; /* 表长减1 */
return OK;
}
Status GetElem(SqList L, int i,ElemT ype &e)
{ /* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */ /* 操作结果：用e返回L中第i个数据元素的值*/
if(i<1 || i>L.length)
return ERROR;
else
{ e=L.elem[i-1];
return e;
}
}
void createlist(SqList &L,int n) //输入全部元素
{ int e;
for(int i=0;i<n;i++)
{ cin>>e;
L.elem[i]=e;
L.length=i+1; }
}
void show(SqList L,int i) //显示全部元素{ int j;
ElemT ype k;
cout<<"顺序表显示如下:"<<endl;
for(j=0;j<i-1;j++) //在元素之间添加"->"号
{ k=L.elem[j];
cout<<k<<"->"; }
if(j==i-1 && i>0)
{ k=L.elem[j]; cout<<k; }
cout<<endl;
}
void Input(SqList &L) //构造一个空的顺序线性表{ int a;
InitList_Sq(L); //分配空间
cout<<"请输入顺序表的长度：";
cin>>a;
cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;
createlist(L,a); //输入全部元素
show(L,a); //显示输入的全部元素}
void looking(SqList &L) //查找指定元素在线性表中的位序{
int *p=L.elem,*q=L.elem+L.length-1;
int j,a,i,m,h;
a=L.length;
cout<<"请输入元素:";
cin>>j;
for(;h=1;)
{for(i=0,m=0;i<a;i++)
if(L.elem[i]==j)m++;
{if(m==0) //判断指定元素是否存在于线性表中
{cout<<"亲，你确认线性表有这个元素吗？出错了:"<<endl;
cout<<"请退出重新输入元素:";
cin>>j;}
else Look(L,j);break; //查找元素
}
}
}
void listdelete(SqList &L) //删除顺序表里指定的元素
{ int a;
int j; ElemT ype e1;
a=L.length;
cout<<"请选择所要删除元素的位置:";
cin>>j;
while(j<0||j>L.length) //判断指定位置是否符合规定
{ cout<<"输入有误，请重新输入"<<endl;
cout<<"请选择所要删除元素的位置:";
cin>>j; }
ListDelete_Sq(L,j,e1); //删除元素
cout<<"修改后的顺序表数据:"<<endl;
show(L,a-1);
}
void Insertlist(SqList &L) //插入元素到顺序表里指定位置{ int a; int j; ElemT ype e1;
a=L.length;
cout<<"请选择所要插入元素的位置:";
cin>>j;
while(j<0||j>L.length)
{ cout<<"输入有误，请重新输入"<<endl;
cout<<"请选择所要插入元素的位置:";
cin>>j; }
cout<<"要插入的元素:";
cin>>e1;
ListInsert(L,j,e1); //插入新元素
cout<<"修改后的顺序表数据:"<<endl;
show(L,a+1); //显示全部元素
}
文件四：seqlistuse.cpp 进行线性表顺序存储结构的基本算法验证
#include"pubuse.h" /* 实现通用常量的定义，常用系统函数的声明*/
#include"seqlistdef.h" /* 采用线性表的动态分配顺序存储结构定义*/
#include"seqlistalgo.h" /* 采用顺序表的基本算法定义*/
void main() //主菜单
{ int chose;
SqList Lx;
for(;;)
{ cout<<" 您好，欢迎使用顺序表的基本操作，根据操作需要选择操作选项前的数字"<<endl;
cout<<" 1.顺序表的创建"<<endl;
cout<<" 2.顺序表的显示"<<endl;
cout<<" 3.查找某元素i在顺序表的位置"<<endl;
cout<<" 4.插入元素到顺序表里"<<endl;
cout<<" 5.删除顺序表里的元素"<<endl;
cout<<" 6.我要退出系统"<<endl;
cout<<" 您选择的操作选项是：";
cin>>chose;
switch(chose)
{ case 1: Input(Lx);break;
case 2: show(Lx,Lx.length);break;
case 3: looking(Lx);break;
case 4: Insertlist(Lx);break;
case 5: listdelete(Lx);break;
case 6: cout<<"我要退出系统!"<<endl;exit(0);break;
default : cout<<"亲，输入有误，请重新选择"<<endl;break;
}
}
}
图1. 等待操作选项输入
图2 .建立线性表L＝｛12,13,21,24,28,31,42,77｝
图3.在第5个元素之前插入26
图4.删除第5个元素28
图5.查找28
(二)使用单链表实现操作:
建立单链表，完成链表（带表头结点）的基本操作：初始化、插入、删除、输出、查找元素、判线性表是否为空；
问题分析：利用单链表,设计一组输入数据，能够对单链表进行如下操作：
从无到有地创建一个单链表是建立起一个链表，即一个一个地输入各结点数据，并建立起前后相互链接的关系。

已给定的值插入到指定位置和删除指定位置的值，形成有序链表；
按值查找，根据给定数据元素的值，查找该元素的位置，对查找结果进行返回；
实现单链表的各个元素的输出；
“初始化算法”的操作结果：构造一个空的线性表L，产生头结点,并使L指向此头结点；
“建立链表算法”初始条件：空链存在；
操作结果：建立一个单链表，并且返回完成的结果；
“链表（位置）插入算法”初始条件：已知单链表L存在；
操作结果：在带头结点的单链线性表L中第i个位置之前插入元素e；
“链表（位置）删除算法”初始条件：已知单链表L存在；
操作结果：在带头结点的单链线性表L中，删除第i个元素,并由e返回其值；
“按值查找算法”初始条件：已知单链表L存在，元素值为e；
其操作结果：返回L中数据元素值为e的元素位置；
线性表的链表存储结构的定义及其基本操作的参考程序（单链表）
文件一：pubuse. h 是公共使用的常量定义和系统函数调用声明
/* 公共使用的常量定义和系统函数调用声明*/
/* (程序名) */
#include<iostream>
using namespace std;
/* 函数结果状态代码*/
#define true 1
#define false 0
#define ok 1
#define error 0
#define overflow -2
typedef int S tatus; /* S tatus是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int ElemT ype;
文件二：linklistdef.h是线性表的单链表存储结构的定义
/* 线性表的单链表存储结构*/
typedef struct LNode
{ ElemT ype data;
struct LNode *next;
}LNode,*LinkList;
文件三：linklistalgo.h是单链表的基本算法描述
/* 单链表线性表的基本操作*/
void CreateList(LinkList &L,int n) //思路类似于算法2.11
{ /* 尾插法创建单链表，建立带表头结构的单链线性表L */
LinkList p;
L=new LNode;
L->next=NULL; /* 先建立一个带头结点的单链表*/
LinkList q=L; //使q指向表尾
for(int i=1;i<=n;i++)
{ p=new LNode;
cin>>p->data; /* 输入元素值*/
p->next=NULL;
q->next=p; /* 插入到表尾*/
q=p; }
}
Status GetElem(LinkList L,int i,ElemT ype &e) /* 思路类似于算法2.8 */
{ /* L为带头结点的单链表的头指针。

当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */
LinkList p=L->next; /* p指向第一个结点*/
int j=1;
while(p&&j<i)
{ p=p->next;
++j; }
if(!p||j>i) return error; //第i个元素不存在
e=p->data; /* 取第i个元素*/
return ok;
}
Status LinkInsert(LinkList &L,int i,ElemT ype e) /* 思路类似于算法2.9 */ { /* 在带头结点的单链线性表L中第i个位置之前插入元素e */ LinkList p=L;
int j=0;
while(p&&j<i-1) /* 寻找第i-1个结点*/
{ p=p->next;
++j; } //寻找第i-1个结点if(!p||j>i-1)
return error; /* i小于1或者大于表长*/
LinkList s=new LNode; //生成新结点
s->data=e; /* 插入L中*/
s->next=p->next;
p->next=s;
return ok;
}
Status ListDelete(LinkList &L,int i,ElemT ype &e) /* 思路类似于算法2.10 */ { /* 在带头结点的单链线性表L中，删除第i个元素,并由e返回其值*/ LinkList p=L;
LinkList q;
int j=0;
while(p->next&&j<i-1)
{ //寻找第i个结点，并令p指向其前驱
p=p->next;
++j; }
if(!(p->next)||j>i-1) return error; //删除位置不合理
q=p->next;
p->next=q->next; //删除并释放结点
e=q->data;
delete(q);
return ok;
}
Status Look(LinkList &L,ElemT ype e) //定义查找函数(查找元素在线性表中的次序)
{
LinkList p=L;
int j=0,i=1;
cout<<"查找元素i单链表中的位置为" ;
for(;p->next;)
{
p=p->next;
++j;
if(p->data==e)
{
cout<<i<<" "; //返回元素在线性表中的次序
}
i++;
}
cout<<endl; return ok;
}
void show(LinkList L) //显示元素
{ LinkList p;
p=L->next;
while(p)
{ cout<<p->data<<"-->";
p=p->next; }
cout<<endl;
}
int Length(LinkList L,int i) //求出表长
{ i=0;
LinkList p=L->next;
while(p)
{ ++i;
p=p->next; }
return i;
}
文件四：linklistuse.cpp 进行线性表链表存储结构的基本算法验证
#include"pubuse.h"
#include"linklistdef.h"
#include"linklistalgo.h"
void main() //主函数
{ int select;
int j,s,x;
ElemT ype y;
LinkList list;
for(;;)
{ cout<<" 您好，欢迎使用顺序表的基本操作，根据操作需要选择操作选项前的数字"<<endl;
cout<<" 1.单链表的创建"<<endl;
cout<<" 2.单链表的显示"<<endl;
cout<<" 3.查找某元素i在单链表的位置"<<endl;
cout<<" 4.插入元素到单链表里"<<endl;
cout<<" 5.删除单链表里的元素"<<endl;
cout<<" 6.退出系统"<<endl;
cout<<"请选择:";
cin>>select;
switch(select)
{ case 1:cout<<"请输入单链表的长度:"<<endl;
cin>>x;
cout<<"请输入"<<x<<"个元素"<<endl;
CreateList(list,x);
break;
case 2: cout<<"单链表显示如下:"<<endl;
show(list);
break;
case 3:cout<<"要查询的元素：";
cin>>j;
Look(list,j) ;
break;
case 4: cout<<"请选择要插入的位置:"; cin>>x;
while(x<0||x>Length(list,s))
{ cout<<"输入有误，请重新输入"<<endl;
cout<<"请选择所要插入元素的位置:";
cin>>x; }
cout<<"要插入的元素值:";
cin>>y;
LinkInsert( list,x,y);
cout<<"插入后单链表显示如下:"<<endl;
show(list);
break;
case 5: cout<<"请选择要删除的位置:"; cin>>x;
while(x<0||x>Length(list,s))
{ cout<<"输入有误，请重新入"<<endl;
cout<<"请选择所要删除元素的位置:";
cin>>x; }
ListDelete(list,x,y);
cout<<"要删除的元素值:"<<y<<endl;
cout<<"删除后的单链表显示如下:"<<endl;
show(list);
break;
case 6: exit(0);
break;
default : cout<<"输入有误，请重新输入"<<endl;
break;
}
}
}
图1. 等待操作选项输入
图2 .建立线性表L＝｛12,13,21,24,28,31,42,77｝
图3.在第5个元素之前插入26
图4.删除第5个元素28
图5.查找28。