数据结构实验报告实验一.docx
《数据结构实验报告实验一.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告实验一.docx（25页珍藏版）》请在冰豆网上搜索。
数据结构实验报告实验一
深圳大学实验报告
课程名称：
数据结构实验与课程设计
实验项目名称：
实验一：
顺序表的应用
学院：
计算机与软件学院
专业：
指导教师：
蔡平
报告人：
文成学号：
2011150259班级：
5
实验时间：
2012-9-17
实验报告提交时间：
2012-9-24
教务部制
一、实验目的与要求：
目的：
1.掌握线性表的基本原理
2.掌握线性表地基本结构
3.掌握线性表地创建、插入、删除、查找的实现方法
要求：
1.熟悉C++语言编程
2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法
二、实验内容：
ProblemA:
数据结构——实验1——顺序表例程
Description
实现顺序表的创建、插入、删除、查找
Input
第一行输入顺序表的实际长度n
第二行输入n个数据
第三行输入要插入的新数据和插入位置
第四行输入要删除的位置
第五行输入要查找的位置
Output
第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开
第二行输出执行插入操作后，顺序表内的所有数据，数据之间用空格隔开
第三行输出执行删除操作后，顺序表内的所有数据，数据之间用空格隔开
第四行输出指定位置的数据
SampleInput
6
112233445566
8883
5
2
SampleOutput
112233445566
112288833445566
1122888335566
22
HINT
第i个位置是指从首个元素开始数起的第i个位置，对应数组内下标为i-1的位置
ProblemB:
数据结构——实验1——顺序表的数据交换
Description
实现顺序表内的元素交换操作
Input
第一行输入n表示顺序表包含的·n个数据
第二行输入n个数据，数据是小于100的正整数
第三行输入两个参数，表示要交换的两个位置
第四行输入两个参数，表示要交换的两个位置
Output
第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开
第二行输出执行第一次交换操作后，顺序表内的所有数据，数据之间用空格隔开
第三行输出执行第二次交换操作后，顺序表内的所有数据，数据之间用空格隔开
注意加入交换位置的合法性检查，如果发现位置不合法，输出error。
SampleInput
5
1122334455
24
01
SampleOutput
1122334455
1144332255
error
HINT
本题执行两次交换操作，注意写好输入接口。
ProblemC:
数据结构——实验1——顺序表的合并
Description
假定两个顺序表的数据已经按照从小到大的顺序排列，实现两个顺序表的合并
Input
第一行输入n表示顺序表A包含的·n个数据
第二行输入n个数据，数据是小于100的正整数
第三行输入m表示顺序表B包含的·n个数据
第二行输入m个数据，数据是小于100的正整数
Output
输出合并后的顺序表内的所有数据，数据之间用空格隔开
SampleInput
3
113355
4
22446688
SampleOutput
11223344556688
问题D:
数据结构——实验1——顺序表的循环移位
题目描述
顺序表的移位是循环移位，例如顺序表：
1，2，3，4，5，6。
如果左移1位，即原来的头元素移动到末尾，其它元素向左移1位，变成2，3，4，5，6，1。
同理，如果右移1位，即原来的尾元素移动到头，其它元素向右移1位，变成6，1，2，3，4，5。
以下是移位的多个例子：
原数据：
1，2，3，4，5，6
左移3位：
4，5，6，1，2，3，与原数据对比
右移4位：
3，4，5，6，1，2，与原数据对比
请编写程序实现顺序表的循环移位操作
输入
第一行输入n表示顺序表包含的·n个数据
第二行输入n个数据，数据是小于100的正整数
第三行输入移动方向和移动的位数，左移方向为0，右移方向为1
第三行输入移动方向和移动的位数，左移方向为0，右移方向为1
输出
第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开
第二行输出执行移位操作后，顺序表内的所有数据，数据之间用空格隔开
第三行输出执行移位操作后，顺序表内的所有数据，数据之间用空格隔开
如果发现输入的移动方向或位数不合法，不执行移位操作，输出error
样例输入
5
1122334455
02
14
样例输出
1122334455
3344551122
4455112233
3、实验步骤与过程：
思路：
1.顺序表类定义
2.顺序表的创建、插入、删除、查找等功能的实现
3.顺序表的测试运行
源代码：
A：
#include
usingnamespacestd;
classList
{
private:
int*elem;//数组元素
intlistsize;//顺序表最大长度
intlength;//顺序表当前长度
public:
List（intsize）;//构造函数
~List（）;//析构函数
intListLength（）;//获取顺序表的实际长度
intListInsert（inti,inte）;//插入一个元素
intListDelete（inti）;//删除一个元素，返回删除的元素
intGetElem（inti）;//获取一个元素，返回元素值
};
List:
:
List（intsize）//构造函数
{
listsize=size;
length=0;
elem=newint[listsize];
}
List:
:
~List（）//析构函数
{
delete[]elem;//回收空间
}
intList:
:
ListLength（）//获取顺序表的实际长度
{
returnlength;
}
intList:
:
ListInsert（inti,inte）//插入一个元素
{
if（length==listsize）
return0;//顺序表已满
if（i<1||i>length+1）
return0;//i值不合法
if（i==length+1）
elem[length]=e;
else
for（intj=length;j>i-1;j--）
elem[j]=elem[j-1];//位置i后面的元素全部后移一位
elem[i-1]=e;
length++;
return1;
}
intList:
:
ListDelete（inti）//删除一个元素，返回删除的元素
{
if（length==0）
return0;
if（i<1||i>length）
return0;
inttemp=elem[i-1];
for（intj=i-1;jelem[j]=elem[j+1];
length--;
returntemp;
}
intList:
:
GetElem（inti）//获取一个元素，返回元素值
{
if（i<1||i>length）
return0;
returnelem[i-1];
}
intmain（）
{
inti,len,temp;
ListmyList（20）;//创建一个顺序表，最大长度为20
cin>>len;
for（i=1;i{
cin>>temp;
myList.ListInsert（i,temp）;
}
for（i=1;icout<cout<intelem,j;
cin>>elem>>j;//输入插入数以及插入的位置
myList.ListInsert（j,elem）;//执行插入操作
for（i=1;icout<cout<cin>>j;//输入删除的位置
myList.ListDelete（j）;//执行删除操作
for（i=1;icout<cout<cin>>j;
cout<return0;
}
B：
#include
usingnamespacestd;
classList
{
private:
int*elem;//数组元素
intlistsize;//顺序表最大长度
intlength;//顺序表当前长度
public:
List（intsize）;//构造函数
~List（）;//析构函数
intListLength（）;//获取顺序表的实际长度
intListInsert（inti,inte）;//插入一个元素
intListDelete（inti）;//删除一个元素，返回删除的元素
intGetElem（inti）;//获取一个元素，返回元素值
intswap（inta,intb）;//交换二个元素
};
List:
:
List（intsize）//构造函数
{
listsize=size;
length=0;
elem=newint[listsize];
}
List:
:
~List（）//析构函数
{
delete[]elem;
}
intList:
:
ListLength（）//获取顺序表的实际长度
{
returnlength;
}
intList:
:
ListInsert（inti,inte）//插入一个元素
{
if（length==listsize）
return0;//顺序表已满
if（i<1||i>length+1）
return0;//i值不合法
if（i==length+1）
elem[length]=e;
else
for（intj=length;j>i-1;j--）//位置i后面的元素全部后移一位
elem[j]=elem[j-1];
elem[i-1]=e;
length++;
return1;
}
intList:
:
ListDelete（inti）//删除一个元素，返回删除的元素
{
if（length==0）
return0;
if（i<1||i>length）
return0;
inttemp=elem[i-1];
for（intj=i-1;jelem[j]=elem[j+1];
length--;
returntemp;
}
intList:
:
GetElem（inti）//获取一个元素，返回元素值
{
if（i<1||i>length）
return0;
returnelem[i-1];
}
intList:
:
swap（inta,intb）//交换二个元素
{
if（a<1||a>length||b<1||b>length||a==b）
{
cout<<"error";//输入不合法，则报错
return0;
}
else
{
inttemp=elem[a-1];//交换元素
elem[a-1]=elem[b-1];
elem[b-1]=temp;
}
return1;
}
intmain（）
{
inti,len,temp;
ListmyList（100）;//创建一个顺序表，最大长度为100
cin>>len;
for（i=1;i{
cin>>temp;
myList.ListInsert（i,temp）;
}
for（i=1;icout<cout<intx,y;//输入交换元素的位置
cin>>x>>y;
if（myList.swap（x,y））//交换这二个元素
{
for（i=1;icout<cout<}
cin>>x>>y;
if（myList.swap（x,y））//交换这二个元素
{
for（i=1;icout<cout<}
return0;
}
C:
#include
usingnamespacestd;
classList
{
private:
int*elem;
intlistsize;//顺序表最大长度
intlength;//顺序表当前长度
public:
List（intsize）;//构造函数
~List（）;//析构函数
intListLength（）;//获取顺序表的实际长度
intListInsert（inti,inte）;//插入一个元素
intListDelete（inti）;//删除一个元素，返回删除的元素
intGetElem（inti）;//获取一个元素，返回元素值
friendintfunc（List&a,List&b）;//实现两个顺序表的合并
};
List:
:
List（intsize）//构造函数
{
listsize=size;
length=0;
elem=newint[listsize];
}
List:
:
~List（）//析构函数
{
delete[]elem;//回收空间
}
intList:
:
ListLength（）//获取顺序表的实际长度
{
returnlength;
}
intList:
:
ListInsert（inti,inte）//插入一个元素
{
if（length==listsize）
return0;//顺序表已满
if（i<1||i>length+1）
return0;//i值不合法
if（i==length+1）
elem[length]=e;
else
for（intj=length;j>i-1;j--）
elem[j]=elem[j-1];//位置i后面的元素全部后移一位
elem[i-1]=e;
length++;
return1;
}
intList:
:
ListDelete（inti）//删除一个元素，返回删除的元素
{
if（length==0）
return0;
if（i<1||i>length）
return0;
inttemp=elem[i-1];
for（intj=i-1;jelem[j]=elem[j+1];//位置i后面的元素全部前移一位
length--;
returntemp;
}
intList:
:
GetElem（inti）//获取一个元素，返回元素值
{
if（i<1||i>length）
return0;
returnelem[i-1];
}
intfunc（List&A,List&B）//实现两个顺序表的合并
{
inta;
for（inti=0;i{
a=-1;
for（intj=0;j{
if（B.elem[i]{
a=j;
break;
}
}
if（a==-1）
{
A.elem[A.length]=B.elem[i];//B.elem[i]是最大的，插到末尾
A.length++;//顺序表当前长度+1
}
else
{
for（intk=A.length-1;k>=a;k--）//位置i后面的元素全部前移一位
A.elem[k+1]=A.elem[k];
A.elem[a]=B.elem[i];//将B.elem[i]插到位置i处
A.length++;//顺序表当前长度+1
}
}
return0;
}
intmain（）
{
inti,len,temp;
ListmyList1（100）;//创建一个顺序表1，最大长度为100
ListmyList2（100）;//创建一个顺序表2，最大长度为100
cin>>len;//输入顺序表1长度
for（i=1;i{
cin>>temp;
myList1.ListInsert（i,temp）;
}
cin>>len;//输入顺序表2长度
for（i=1;i{
cin>>temp;
myList2.ListInsert（i,temp）;
}
func（myList1,myList2）;//将顺序表1与顺序表2合并
for（i=1;icout<cout<return0;
}
D:
#include
usingnamespacestd;
classList
{
private:
int*elem;
intlistsize;//顺序表最大长度
intlength;//顺序表当前长度
public:
List（intsize）;//构造函数
~List（）;//析构函数
intListLength（）;//获取顺序表的实际长度
intListInsert（inti,inte）;//插入一个元素
intListDelete（inti）;//删除一个元素，返回删除的元素
intGetElem（inti）;//查找一个元素，返回元素值
intMove（inta,intb）;
};
List:
:
List（intsize）//构造函数
{
listsize=size;
length=0;
elem=newint[listsize];
}
List:
:
~List（）//析构函数
{
delete[]elem;//回收空间
}
intList:
:
ListLength（）//获取顺序表的实际长度
{
returnlength;
}
intList:
:
ListInsert（inti,inte）//插入一个元素
{
if（length==listsize）
return0;//顺序表已满
if（i<1||i>length+1）
return0;//i值不合法
if（i==length+1）
elem[length]=e;
else
for（intj=length;j>i-1;j--）
elem[j]=elem[j-1];//位置i后面的元素全部后移一位
elem[i-1]=e;
length++;
return1;
}
intList:
:
ListDelete（inti）//删除一个元素，返回删除的元素
{
if（length==0）
return0;
if（i<1||i>length）
return0;
inttemp=elem[i-1];
for（intj=i-1;jelem[j]=elem[j+1];//位置i后面的元素全部前移一位
length--;
returntemp;
}
intList:
:
GetElem（inti）//查找一个元素，返回元素值
{
if（i<1||i>length）
return0;
returnelem[i-1];
}
intList:
:
Move（inta,intb）
{
inti,j;
int*p=newint[2*length];//先构造一个2倍长度的空间
for（i=0;ip[i]=elem[i];
for（j=0;jp[i]=elem[j];//实际上p指向的是elem*2的数组
if（a==0）//若a==0，则向左移
for（i=0;ielem[i]=p[i+b];//将向左移b位后的结果给elem
if（a==1）//若a==1，则向右移
for（i=0;ielem[i]=p[i+length-b];//将向右移b位后的结果给elem
return0;
}
intmain（）
{
inti,len,temp;
ListmyList（100）;//创建一个顺序表，最大长度为100
cin>>len;//
升级会员 