数据结构实验报告实验一Word文件下载.docx

数据结构实验报告实验一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（）