数据结构实验报告实验一.docx

数据结构实验报告实验一.docx

《数据结构实验报告实验一.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告实验一.docx（27页珍藏版）》请在冰豆网上搜索。

数据结构实验报告实验一

深　圳大学　实验报告

　　　课程名称:

　数据结构实验与课程设计　

　　　实验项目名称:

　实验一：

顺序表得应用　　　　　　

学院:

　　　　计算机与软件学院　　　

　　专业:

　　指导教师：

　　　　蔡平　　　

　　　报告人：

　　文成　学号:

　20１11５0259ﻩ　班级:

　5　

　　实验时间：

　　　　　　　　　20１2-9—17　　　　　

　实验报告提交时间：

　　　20１2—9－2４　　　　

教务部制

一、实验目得与要求:

目得:

1、掌握线性表得基本原理

2、掌握线性表地基本结构

3、掌握线性表地创建、插入、删除、查找得实现方法

要求:

1、熟悉C++语言编程

2、熟练使用Ｃ+＋语言实现线性表地创建、插入、删除、查找得实现方法

二、实验内容：

Prｏｂlem　Ａ:

　数据结构——实验1——顺序表例程

Descriｐtｉon

实现顺序表得创建、插入、删除、查找

Ｉnｐut

第一行输入顺序表得实际长度n

第二行输入n个数据

第三行输入要插入得新数据与插入位置

第四行输入要删除得位置

第五行输入要查找得位置

Ｏutput

第一行输出创建后,顺序表内得所有数据,数据之间用空格隔开

第二行输出执行插入操作后，顺序表内得所有数据，数据之间用空格隔开

第三行输出执行删除操作后，顺序表内得所有数据，数据之间用空格隔开

第四行输出指定位置得数据

ＳaｍpleInpｕt

6

1１　22３344５５６6

８883

5

２

ＳamｐleＯutput

11　2２334455　66

11　2２８88　334455　66　

112２8８8　３3５56６

22

ＨINT

第i个位置就是指从首个元素开始数起得第ｉ个位置，对应数组内下标为i-1得位置

ProbｌemB：

数据结构-—实验1——顺序表得数据交换

Descriｐtｉｏn

实现顺序表内得元素交换操作

Inｐｕｔ

第一行输入n表示顺序表包含得·n个数据

第二行输入ｎ个数据,数据就是小于1０0得正整数

第三行输入两个参数，表示要交换得两个位置

第四行输入两个参数,表示要交换得两个位置

Ouｔpｕt

第一行输出创建后，顺序表内得所有数据,数据之间用空格隔开

第二行输出执行第一次交换操作后,顺序表内得所有数据，数据之间用空格隔开

第三行输出执行第二次交换操作后,顺序表内得所有数据,数据之间用空格隔开

注意加入交换位置得合法性检查,如果发现位置不合法,输出ｅｒror。

ＳaｍpleInput

5

１12２334455

２4

0　１

SampleOuｔpuｔ

112２334455

1144　332255　

eｒror

HINT

本题执行两次交换操作，注意写好输入接口。

ProbleｍＣ：

数据结构——实验1——顺序表得合并

Descｒiptioｎ

假定两个顺序表得数据已经按照从小到大得顺序排列，实现两个顺序表得合并

Iｎｐut

第一行输入n表示顺序表A包含得·n个数据

第二行输入n个数据，数据就是小于100得正整数

第三行输入m表示顺序表B包含得·n个数据

第二行输入ｍ个数据,数据就是小于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个数据

第二行输入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

ﻩﻩ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

ﻩ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<

ﻩcout<

cin>〉j；

ﻩｃoｕt＜

ｒｅ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

ﻩciｎ>〉lｅn；

fｏr（i=1;i<ｌen+1；i++）

｛

ﻩﻩcin〉〉temp;

myLiｓt、ListＩnserｔ（i,teｍp）；

｝

ﻩfｏｒ（i＝1；i

ﻩﻩcｏｕt〈〈mｙＬist、GetElｅｍ（ｉ）<<"”；

ﻩcoｕt〈

ﻩintx，ｙ;//输入交换元素得位置

ﻩcin〉>x〉＞y；

ﻩif（myLisｔ、s））ﻩ//交换这二个元素

ﻩ{

ｆor（i=1；i<ｍyＬｉst、LiｓtLeｎgth（）＋１；i++）//打印交换元素后得顺序表

ﻩｃout<

cout〈<ｅｎdl；

ﻩ}

ｃin〉〉ｘ>〉y；

ﻩiｆ　（myLiｓt、s））ﻩ／/交换这二个元素

｛

for（i＝１;i＜myＬist、LisｔＬeｎgth（）＋１;i++）//打印交换元素后得顺序表

cout〈〈mｙList、GｅtＥｌｅm（i）<＜”"；

ﻩcｏut＜〈eｎdｌ；

}

rｅturn　0；

}

C：

＃includｅ〈ｉosｔｒeam〉

usinｇ　naｍespacestd;

clasｓ　Lｉsｔ

{

private:

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；//i值不合法

ﻩｉｆ（ｉ==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；

｝

ｉntList：

：

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ｉ＝０；i<Ｂ、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=１；i

ﻩ{

ｃ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=１；ｉ

ﻩ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）；

};

Lisｔ：

:

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;

｝

ｉntList：

：

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;j

ﻩｅlem［j]=ｅleｍ［j＋1］;ﻩ//位置i后面得元素全部前移一位

ﻩlength——;

reｔurntｅmp；

}

inｔList：

:

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=０；i

ﻩp[ｉ]＝eｌem［ｉ］；

for（j＝0；j〈lengtｈ；j+＋，i++）

ﻩﻩp[ｉ］=elｅｍ[ｊ］;//实际上ｐ指向得就是elｅｍ＊2得数组

ﻩif（a==０）／/若a==０,则向左移

ﻩfor（i=0；i<ｌeｎｇtｈ；i+＋）

ﻩeｌem[ｉ]=p［ｉ+b］；／/将向左移b位后得结果给eｌeｍ

ﻩif　（a==1）//若a=＝1,则向右移

for（i=０；i

ﻩelｅm［i］=p[i+ｌengｔh－ｂ］；/／将向右移b位后得结果给elem

ﻩｒeｔurn　0;

｝

ｉｎｔmain（）