数据结构实验报告实验一Word文件下载.docx
《数据结构实验报告实验一Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告实验一Word文件下载.docx（27页珍藏版）》请在冰豆网上搜索。
第二行输入ｎ个数据,数据就是小于1０0得正整数
第三行输入两个参数，表示要交换得两个位置
第四行输入两个参数,表示要交换得两个位置
Ouｔpｕt
第一行输出创建后，顺序表内得所有数据,数据之间用空格隔开
第二行输出执行第一次交换操作后,顺序表内得所有数据，数据之间用空格隔开
第三行输出执行第二次交换操作后,顺序表内得所有数据,数据之间用空格隔开
注意加入交换位置得合法性检查,如果发现位置不合法,输出ｅｒror。
ＳaｍpleInput
１12２334455
２4
0 １
SampleOuｔpuｔ
112２334455
1144 332255
eｒror
HINT
本题执行两次交换操作，注意写好输入接口。
ProbleｍＣ：
数据结构——实验1——顺序表得合并
Descｒiptioｎ
假定两个顺序表得数据已经按照从小到大得顺序排列，实现两个顺序表得合并
Iｎｐut
第一行输入n表示顺序表A包含得·
第二行输入n个数据，数据就是小于100得正整数
第三行输入m表示顺序表B包含得·
第二行输入ｍ个数据,数据就是小于1０0得正整数
Ｏutpuｔ
输出合并后得顺序表内得所有数据,数据之间用空格隔开
Sａmple Iｎput
3
1１3355
4
22 ４46688
Samｐｌe Output
11 ２２3３ 445５６68８
问题D:
数据结构—-实验1——顺序表得循环移位
题目描述
顺序表得移位就是循环移位,例如顺序表：
１，2,3，4，5，6。
如果左移1位,即原来得头元素移动到末尾,其它元素向左移1位，变成2，３，4,5，6,1。
同理，如果右移1位,即原来得尾元素移动到头，其它元素向右移1位，变成6，1,２，3，4,5.以下就是移位得多个例子：
原数据:
１，2,3，4,5,6
左移3位:
4，５，6,１，2，3,与原数据对比
右移４位：
３，4,5，6，1,２，与原数据对比
请编写程序实现顺序表得循环移位操作
输入
第一行输入ｎ表示顺序表包含得·
第二行输入n个数据，数据就是小于10０得正整数
第三行输入移动方向与移动得位数,左移方向为0,右移方向为1
第三行输入移动方向与移动得位数,左移方向为0，右移方向为1
输出
第一行输出创建后，顺序表内得所有数据，数据之间用空格隔开
第二行输出执行移位操作后，顺序表内得所有数据，数据之间用空格隔开
第三行输出执行移位操作后，顺序表内得所有数据，数据之间用空格隔开
如果发现输入得移动方向或位数不合法，不执行移位操作,输出eｒｒｏr
样例输入
５
１1 2233４455
0 2
１ 4
样例输出
１1223３44 55
３34４5５１1２２
445５1１2233
3、实验步骤与过程：
思路:
1.顺序表类定义
２、顺序表得创建、插入、删除、查找等功能得实现
3、顺序表得测试运行
源代码:
A：
＃incluｄｅ＜iostream>
usingnａmeｓpacestd；
cｌａssLｉsｔ
｛
pｒｉvａte:
iｎｔ*elem；
ﻩ//数组元素
ｉnｔlistsｉze；
ﻩ//顺序表最大长度
ﻩintleｎgth；
ﻩ／/顺序表当前长度
public:
Ｌｉst（intsize）;
ﻩ/／构造函数
~Lｉｓt（）;
//析构函数
iｎtＬistLenｇth（）;
／/获取顺序表得实际长度
ｉntLiｓtInserｔ（ｉｎt i，inte）；
ﻩ/／插入一个元素
ﻩinｔListＤeｌｅte（iｎｔｉ）；
//删除一个元素，返回删除得元素
inｔGetElem（ｉnｔi）；
ﻩﻩ／／获取一个元素，返回元素值
｝;
Liｓt：
：
Lisｔ（inｔ ｓｉｚe）//构造函数
{
ﻩｌistｓize＝sｉzｅ;
lenｇth＝0；
eｌem＝new int［ｌistsizｅ］;
}
Lｉsｔ:
~List（）／/析构函数
ﻩdｅｌｅte［]ｅlem；
／/回收空间
｝
intLｉst:
:
ＬistＬengｔｈ（）ﻩ//获取顺序表得实际长度
ﻩｒetuｒnｌength；
inｔList：
LｉstInｓert（ｉnti,ｉnte）ﻩ／/插入一个元素
ｉf（lengtｈ==liｓtｓｉze）
ﻩｒetｕrn0；
ﻩ//顺序表已满
iｆ（i<
1｜|ｉ>
lｅngth+１）
ﻩreturn０；
//i值不合法
ﻩif（i=＝ｌengｔh+1）
ﻩelｅｍ［length］＝e；
ｅlsｅ
ﻩﻩｆoｒ（iｎt ｊ＝lengｔh；
j>
i—1;
ｊ-—）
elem[j]=ｅlem[j-1]；
//位置i后面得元素全部后移一位
ﻩelem［i—1]=e;
ﻩｌｅngｔh＋＋；
retuｒn1；
inｔLiｓt:
LｉstDelｅte（ｉｎti）//删除一个元素，返回删除得元素
ﻩiｆ （lengtｈ=＝0）
ﻩreｔurn0；
ﻩif （ｉ〈1|｜i>
lengtｈ）
reｔｕｒｎ0;
intｔｅmｐ=elem[i—1];
ﻩfｏr（intj=ｉ－1；
j<
leｎgth;
j++）ﻩ/／位置i后面得元素全部前移一位
ﻩﻩelem［j]=ｅlｅm[j＋1]；
ﻩlength-—;
ﻩrｅｔuｒntemｐ;
intLiｓt:
GetElｅm（iｎti）//获取一个元素,返回元素值
ﻩif（i＜1｜｜i>
lengｔh）
ﻩﻩretｕrn0；
ﻩrｅｔurｎelem［ｉ—1];
inｔmain（）
ﻩinｔｉ，lｅｎ，ｔｅmｐ;
LiｓtmｙLisｔ（２0）；
ﻩ／/创建一个顺序表，最大长度为20
ciｎ〉〉len;
ﻩｆor（i=1；
i〈ｌen＋1;
i+＋）
ﻩ｛
cin>
〉ｔemp;
mｙLｉｓｔ、ListIｎｓeｒt（ｉ,temｐ）；
ﻩ}
ﻩfor（ｉ＝1；
i<
myＬist、LｉｓtLｅngth（）+１；
i++）ﻩ／/打印顺序表
ﻩcout〈〈mｙＬist、GetElｅm（i）〈〈””；
cｏut〈〈ｅｎｄl；
ﻩiｎt ｅleｍ,j；
ﻩ
ｃiｎ＞>
eleｍ＞〉j;
ﻩ／/输入插入数以及插入得位置
myList、ＬｉsｔInseｒｔ（j,ｅｌem）；
ﻩ//执行插入操作
for（i=1；
i＜ｍyLiｓt、ＬisｔLengtｈ（）＋1;
i++）/／打印插入后得结果
ﻩcout<
〈myＬｉｓｔ、GｅtElem（i）<
<
” "
；
ﻩcｏuｔ<
〈ｅndl；
ﻩciｎ>
＞j；
/／输入删除得位置
ﻩmyLiｓｔ、ListＤeleｔe（ｊ）；
ﻩ/／执行删除操作
for（ｉ=１；
i〈ｍｙLｉst、ListLengｔh（）+１；
i++）//打印插入后得结果
ｃｏut<
mｙList、ＧｅtＥlｅm（i）<
〈"
＂;
ﻩcout<
endl；
cin>
〉j；
ﻩｃoｕt＜<
myList、ＧetElem（ｊ）〈<
ｅndl；
／/输出指定位置得数据
ｒｅturｎ 0；
B:
＃include＜iostrｅam〉
usｉng namｅｓｐaｃestd;
cｌassLisｔ
private:
ﻩｉnt*eｌeｍ；
ﻩ//数组元素
int ｌｉstsizｅ;
//顺序表最大长度
ﻩｉntlength;
ﻩﻩ//顺序表当前长度
pｕbｌｉc：
Lｉｓt（iｎtｓize）;
//构造函数
ﻩ～Liｓt（）;
intＬistLength（）；
ﻩ/／获取顺序表得实际长度
ﻩinｔListＩnｓert（inti,iｎte）；
//插入一个元素
iｎtＬiｓtDeｌete（iｎtｉ）；
//删除一个元素，返回删除得元素
iｎtGetＥｌｅm（ｉnｔ i）;
ﻩﻩ//获取一个元素，返回元素值
ﻩiｎtsa,ｉnｔb）;
ﻩﻩ//交换二个元素
}；
Lisｔ:
List（inｔｓize）//构造函数
ﻩｌistｓiｚｅ＝size;
ﻩlength=0;
ｅlem=ｎeｗｉnt[lｉstｓize］；
Ｌiｓt：
~List（）／／析构函数
ﻩdeｌete[]eｌeｍ；
intLｉst：
ListＬｅngｔｈ（）//获取顺序表得实际长度
ﻩreturn ｌength;
intLｉｓt：
ListＩnｓert（ｉnt ｉ,iｎt e）／/插入一个元素
if（lenｇtｈ＝=ｌｉstsｉze）
return0;
//顺序表已满
ﻩｉf（ｉ＜1|｜i〉ｌｅnｇth＋１）
ﻩreturn0;
ﻩ//i值不合法
ｉf （ｉ==lｅngth＋1）
elem［ｌenｇth]=e;
ｅlse
ﻩfｏｒ（intj=length;
j〉i—1；
j-—）ﻩ//位置i后面得元素全部后移一位
ﻩelｅｍ［j]=eleｍ[j-1］；
eleｍ［i－1］=e；
ﻩｌength+＋；
ﻩretuｒn1;
ｉntList：
ＬｉｓtＤelete（inｔｉ）//删除一个元素，返回删除得元素
ﻩiｆ（ｌｅnｇth=＝０）
return 0；
ﻩｉf（ｉ<
1｜|ｉ＞lenｇｔh）
ﻩretuｒn0；
ﻩｉｎtｔemp＝elem[i—１］；
ﻩfor （iｎｔｊ=ｉ—1;
j＜length;
j++）ﻩﻩ/／位置i后面得元素全部前移一位
ﻩelｅm[j］=ｅleｍ［j＋１］；
ﻩｌeｎgth——;
reｔurntemp;
iｎｔLｉｓt:
GetEｌeｍ（inti）ﻩ/／获取一个元素，返回元素值
ﻩif（i＜1｜|i＞leｎgth）
ﻩrｅturn0；
ﻩreturn elem［ｉ-1];
ｉnｔＬisｔ：
sa,intb）／／交换二个元素
iｆ （a＜1｜｜a〉length ||b〈1||b〉lengtｈ｜|a=＝b）
ﻩ{ﻩ
ﻩｃｏut〈＜"
erｒor”；
ﻩ//输入不合法，则报错
ﻩrｅｔurn ０；
else
{
ﻩinttemp＝eｌem［a-1];
ﻩ//交换元素
elem[ａ-１］＝elｅm[b-1]；
elem[ｂ-1］=ｔemｐ；
ﻩ｝
return1;
ｉnt ｍaｉn（）
iｎｔ i,ｌｅn,temp;
LｉstmyＬist（100）；
ﻩ//创建一个顺序表,最大长度为１00
〉lｅn；
fｏr（i=1;
ｌen+1；
i++）
｛
ﻩﻩcin〉〉temp;
myLiｓt、ListＩnserｔ（i,teｍp）；
｝
ﻩfｏｒ（i＝1；
myLｉst、ListLength（）+1;
i++）ﻩ//打印顺序表
ﻩﻩcｏｕt〈〈mｙＬist、GetElｅｍ（ｉ）<
"
”；
ﻩcoｕt〈<
endl;
ﻩintx，ｙ;
//输入交换元素得位置
ﻩcin〉>
x〉＞y；
ﻩif（myLisｔ、s））ﻩ//交换这二个元素
ﻩ{
ｆor（i=1；
ｍyＬｉst、LiｓtLeｎgth（）＋１；
i++）//打印交换元素后得顺序表
ﻩｃout<
myLｉｓｔ、GetElem（i）<
cout〈<
ｅｎdl；
ｃin〉〉ｘ>
〉y；
ﻩiｆ （myLiｓt、s））ﻩ／/交换这二个元素
for（i＝１;
i＜myＬist、LisｔＬeｎgth（）＋１;
cout〈〈mｙList、GｅtＥｌｅm（i）<
＜”"
ﻩcｏut＜〈eｎdｌ；
}
rｅturn 0；
C：
＃includｅ〈ｉosｔｒeam〉
usinｇ naｍespacestd;
clasｓ Lｉsｔ
int *eleｍ；
int ｌisｔsizｅ;
ﻩ／／顺序表最大长度
ﻩintｌength；
//顺序表当前长度
pｕblic：
ﻩList（ｉntsｉze）;
//构造函数
~Ｌｉst（）；
ﻩ//析构函数
ﻩintＬistLｅngth（）；
ﻩ//获取顺序表得实际长度
iｎt LiｓtＩnｓｅrｔ（inti，ｉnte）；
ﻩinｔListDeletｅ（inti）;
ﻩ//删除一个元素，返回删除得元素
ﻩintＧeｔElｅm（ｉntｉ）；
ﻩﻩ/／获取一个元素，返回元素值
ﻩｆrieｎｄintfuｎc（Ｌist＆a，List &
b）;
/／实现两个顺序表得合并
｝；
Lisｔ：
Ｌist（int sizｅ）ﻩ/／构造函数
liｓtsizｅ=size;
ｌeｎgth=０；
elem=newinｔ［listsize];
List：
～Ｌisｔ（）ﻩﻩ／/析构函数
ﻩdelｅte［］eｌem；
／/回收空间
ｉntLｉｓt：
ListLｅngth（）//获取顺序表得实际长度
ﻩretuｒｎlength；
intＬｉsｔ:
ListInｓerｔ（int ｉ,inte）ﻩ//插入一个元素
ﻩif（ｌength==listsiｚｅ）
ﻩreturｎ０;
ﻩ／／顺序表已满
iｆ（ｉ<
１|｜i>
ｌengｔh+1）
ﻩreturｎ0；
ﻩｉｆ（ｉ==lｅngｔh+1）
ﻩelem[lenｇth］＝ｅ;
elｓe
ﻩfoｒ （int ｊ=lｅｎｇth；
j〉i-１；
j--）
ﻩelem[j］=eｌeｍ[j—1]；
ﻩ／／位置i后面得元素全部后移一位
elem[i-１]=e;
ｌenｇth++；
ﻩreturn1；
LｉstDelete（inti）ﻩ／/删除一个元素,返回删除得元素
ﻩiｆ（length==0）
ﻩﻩrｅtｕｒn0;
ﻩｉf（i<
１|｜i〉ｌｅｎｇth）
reｔuｒｎ0;
ｉntｔemp=ｅlｅm［i—１];
ﻩfor（inｔｊ＝i—1；
j＜lengtｈ；
j＋+）
ﻩｅlem［j］=elem［j+1］；
ﻩ／/位置i后面得元素全部前移一位
ﻩleｎgth—－;
ﻩretｕrnｔｅｍp；
ｉnｔList:
ＧｅtＥlem（inｔi）ﻩ／/获取一个元素,返回元素值
ﻩif（i＜1||i〉lｅngth）
ﻩﻩrｅtuｒn ０;
ﻩretｕrｎ elｅｍ[i—1]；
inｔｆunｃ（Liｓt&
A,Ｌisｔ ＆B）ﻩ//实现两个顺序表得合并
ﻩｉnt a；
fｏr（intｉ＝０；
Ｂ、ListLength（）;
i＋＋）
ﻩ｛
a=—1;
ﻩfor（iｎtj=0；
j＜A、ListLenｇth（）;
j＋＋）
ﻩ｛
ﻩﻩﻩif（B、elｅm［i]＜A、eｌem［j]）／/寻找插入得位置
ﻩﻩ{
ﻩﻩa＝j；
ﻩﻩﻩﻩｂrｅａk；
ﻩ}
｝
ﻩif（ａ==—1）
ﻩ｛
ﻩﻩﻩＡ、elem[A、lｅngth］=B、ｅlｅｍ［i］;
ﻩ/／B、ｅleｍ[i］就是最大得,插到末尾
ﻩﻩA、lｅngtｈ++；
//顺序表当前长度+1
ﻩ｝
ﻩeｌｓe
ﻩfｏr（inｔ k=Ａ、lｅngｔh—1；
k＞=ａ；
k—-）//位置i后面得元素全部前移一位
ﻩﻩﻩA、eｌem[k+１]=A、eｌem［k］;
A、eleｍ［ａ]=Ｂ、elem［i］;
//将B、elｅm［i］插到位置i处
ﻩ A、lenｇth++；
/／顺序表当前长度+1
ﻩ}
ﻩｒeturn０;
int main（）
intｉ,ｌen,tｅmp；
ﻩList myLｉsｔ1（100）;
／／创建一个顺序表１,最大长度为1００
ﻩLisｔmyLiｓｔ2（10０）；
ﻩ//创建一个顺序表2,最大长度为１0０
ｃiｎ>
〉lｅｎ；
//输入顺序表1长度
for（i=１；
len+１；
ｉ+＋）/／输入数据
ｃiｎ>
>
temｐ;
ﻩmyＬｉst1、LｉｓｔIｎserｔ（ｉ，tｅmp）；
cin〉＞len；
／/输入顺序表2长度
ﻩfor（i=1;
ｉ＜len+1；
i＋＋）／／输入数据
ciｎ>
＞tｅmp;
ﻩmyLiｓt２、ＬｉstInsert（ｉ,temｐ）;
ﻩｆuｎc（ｍyList1,ｍyＬisｔ2）；
ﻩ／/将顺序表1与顺序表2合并
ｆｏr（i=１；
ｉ<
mｙLｉｓt1、LiｓtLengtｈ（）+1;
i++）ﻩ／/输出合并后得结果
ﻩcｏuｔ〈〈mｙLisｔ1、GetElｅm（i）<
＂；
ﻩcout＜<
return０;
D:
＃inclｕde＜ioｓtream〉
usｉｎgnamｅspaｃe sｔd;
cｌass Lｉst
priｖａte：
int*eleｍ;
ﻩinｔlisｔｓizｅ；
ｉnｔ length;
ﻩ//顺序表当前长度
pｕblic:
ﻩList（intsｉze）;
~Liｓt（）;
ﻩﻩ//析构函数
intLｉstＬenｇth（）;
ﻩintＬistInｓert（inti，intｅ）；
ﻩ//插入一个元素
ﻩint ListDelete（inｔｉ）;
//删除一个元素,返回删除得元素
intGetEleｍ（int i）；
ﻩﻩ／/查找一个元素，返回元素值
inｔ Moｖe（intａ，ｉｎtb）；
};
List（ｉｎｔsize）//构造函数
liｓtsize＝size;
ﻩlenｇth=0;
ﻩｅlem=new int[ｌｉｓtsizｅ］;
Ｌist:
~List（）ﻩﻩ//析构函数
ﻩdeletｅ［］eleｍ；
/／回收空间
ｉｎt Lｉsｔ:
ＬisｔLｅｎｇｔh（）／/获取顺序表得实际长度
ﻩｒeｔuｒｎlength;
intＬiｓt：
ListＩnｓerｔ（int ｉ，inte）//插入一个元素
ﻩif （lｅngth==lisｔsizｅ）
ﻩｒeｔｕrn 0；
if （i<
1｜|i>
length+1）
ﻩreｔｕｒn0;
/／ｉ值不合法
ﻩif（ｉ==length+1）
ﻩelｅm[lengtｈ］＝e；
ﻩeｌse
ｆor （iｎｔj=lｅngｔｈ；
j＞i-１；
j-－）
eｌem［ｊ]=ｅlｅm[ｊ—1］；
ﻩ//位置i后面得元素全部后移一位
elem［i－1]=ｅ;
ﻩｌengtｈ++;
ﻩｒetｕrn1;
ListDeleｔe（ｉnti）ﻩ//删除一个元素，返回删除得元素
ｉf（lenｇｔh＝＝0）
ﻩﻩreｔuｒn０;
ﻩiｆ（i＜1|｜i>
ｌength）
ﻩﻩretｕｒn ０;
ｉnttemｐ=eleｍ［i－1］;
ﻩｆor（ｉntj＝i-1;
lenｇth;
ｊ＋+）
ﻩｅlem［j]=ｅleｍ［j＋1］;
ﻩ//位置i后面得元素全部前移一位
ﻩlength——;
reｔurntｅmp；
GetElem（intｉ）ﻩ／/查找一个元素,返回元素值
if（ｉ〈1｜｜ ｉ>
leｎｇth）
ﻩﻩｒetｕrn０;
retuｒneｌeｍ［i－１］;
inｔ Liｓｔ:
Mｏve（ｉnta，inｔ b）
ﻩint i，ｊ；
ﻩiｎt ＊p＝nｅｗｉnt［2*lengｔｈ]；
／/先构造一个２倍长度得空间
fｏr（i=０；
leｎgｔh；
i＋+）
ﻩp[ｉ]＝eｌem［ｉ］；
for（j＝0；
j〈lengtｈ；
j+＋，i++）
ﻩﻩp[ｉ］=elｅｍ[ｊ］;
//实际上ｐ指向得就是elｅｍ＊2得数组
ﻩif（a==０）／/若a==０,则向左移
ﻩfor（i=0；
ｌeｎｇtｈ；
ﻩeｌem[ｉ]=p［ｉ+b］；
／/将向左移b位后得结果给eｌeｍ
ﻩif （a==1）//若a=＝1,则向右移
for（i=０；
length；
ﻩelｅm［i］=p[i+ｌengｔh－ｂ］；
/／将向右移b位后得结果给elem
ﻩｒeｔurn 0;
ｉｎｔmain（）
升级会员 