2数据结构实验2顺序表.docx

2数据结构实验2顺序表.docx

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

2数据结构实验2顺序表

实验报告

院（系）：

信息科学与技术学院课程名称：

数据结构日期：

班级

学号

实验室

专业

姓名

计算机号

实验名称

实验2顺序表的操作

成绩评定

所用软件

VC

教师签名

实

验

目

的

1.掌握线性表的基本概念

2.掌握顺序表的建立、插入和删除等方法。

3.掌握顺序表的基本算法。

实

验

准

备

1.复习书上有关内容。

2.阅读实验步骤中的函数，写出函数功能。

3.写出实验步骤2、3、4的源程序。

（本次实验需4学时）

实

验

内

容

第一部分（2学时）

1.分析下列程序并上机运行，写出各子函数功能并写出运行结果。

#defineMAXSIZE100

typedefintelemtype;

typedefstruct

{elemtypeelem[MAXSIZE];

intlast;

}sqlist;

sqlist*init_sqlist（）

{sqlist*L;

L=（sqlist*）malloc（sizeof（sqlist））;

L->last=-1;returnL;

}

voidcreatsqlist（sqlist*L）

{inti;

printf（"%d",L->last）;

scanf（"%d",&（*L）.last）;

for（i=0;i<=（*L）.last;i++）

scanf（"%d",&（*L）.elem[i]）;

}

intLocation_sqlist（sqlist*L,intx）

{inti=0;

while（i<=L->last&&L->elem[i]!

=x）

i++;

if（i>L->last）return-1;

elsereturni;

}

intInsList（sqlist*L,inti,intx）

{

intk;

if（（i<1）||（i>L->last+2））

{printf（"LocateError!

"）;return（0）;}/*位置i值不合法*/

if（L->last>=MAXSIZE-1）

{printf（"Filled!

"）;return（0）;}

for（k=L->last;k>=i-1;k--）

L->elem[k+1]=L->elem[k];/*插入位置后的元素依次右移*/

L->elem[i-1]=x;/*插入x*/

L->last++;/*表长加1*/

return

（1）;

}

voidmain（）

{inti;

sqlist*a;

clrscr（）;

a=init_sqlist（）;

creatsqlist（a）;

printf（"%d\n",Location_sqlist（a,3））;

for（i=0;i<=a->last;i++）printf（"%d",a->elem[i]）;

if（InsList（a,2,78））printf（"\nOK!

"）;/*执行函数调用*/

elseprintf（"\nERROR!

"）;

for（i=0;i<=a->last;i++）printf（"%d",a->elem[i]）;

}

2.下列函数的功能是在顺序表中删除第i个元素，请编制主函数进行函数调用，上机调试运行。

i#include

#include

#defineERROR0

#defineMAXSIZE100

typedefintelemtype;

typedefstruct

{elemtypeelem[MAXSIZE];

intlast;

}SeqList;

intDelList（SeqList*L,inti,elemtype*e）

/*在顺序表L中删除第i个数据元素，并用指针参数e返回其值。

i的合法取值为1≤i≤L.last+1*/

{

intk;

if（（i<1）||（i>L->last+1））

{

printf（"删除位置不合法!

"）;

return（ERROR）;

}

*e=L->elem[i-1];/*将删除的元素存放到e所指向的变量中*/

for（k=i;i<=L->last;k++）

L->elem[k-1]=L->elem[k];/*将后面的元素依次前移*/

L->last--;

return

（1）;

}

main（）

{

intn,x;

SeqList*t;

SeqList*e;

printf（"请输入数组：

\n"）;

for（n=0;n<（*t）->last;n++）

{

scanf（"%d",&（*t）->elem[n]）;

}

printf（"请输入要删除的位置：

\n"）;

scanf（"%d",&x）;

x=DelList（t,x,e）;

if（x）

{

for（n=0;n<=t->last;n++）

{

printf（"%d\n",t->elem[i]）;

}

}

else

printf（"\n"）;

}

3.阅读下列函数，写该函数的功能，再编制主函数进行函数调用，写出运行结果。

#defineMAXSIZE100

#include"stdio.h"

#include"stdlib.h"

typedefintelemtype;

typedefstruct

{elemtypeelem[MAXSIZE];

intlast;

}sqlist;

sqlist*init_sqlist（）

{sqlist*L;

L=（sqlist*）malloc（sizeof（sqlist））;

L->last=-1;returnL;

}

voidcreatsqlist（sqlist*L）

{inti;

printf（"请输入线性表的长度"）;

scanf（"%d",&i）;

L->last=i-1;

printf（"请输入线性表中的各元素值，注意：

必须有序"）;

for（i=0;i<=L->last;i++）

scanf（"%d",&（*L）.elem[i]）;

}

voidmerge（sqlist*LA,sqlist*LB,sqlist*LC）

{

inti,j,k;

i=0;j=0;k=0;

while（i<=LA->last&&j<=LB->last）

if（LA->elem[i]<=LB->elem[j]）

{

LC->elem[k]=LA->elem[i];

i++;

k++;

}

else

{

LC->elem[k]=LB->elem[j];

j++;

k++;

}

while（i<=LA->last）/*当表LA有剩余元素时，则将表LA余下的元素赋给表LC*/

{

LC->elem[k]=LA->elem[i];

i++;

k++;

}

while（j<=LB->last）/*当表LB有剩余元素时，则将表LB余下的元素赋给表LC*/

{

LC->elem[k]=LB->elem[j];

j++;

k++;

}

LC->last=LA->last+LB->last+1;

}

4.若顺序表a中的数据元素按升序排列，要求将x插入到顺序表中的合适位置，以保证表的有序性，试给出其程序，并上机调试运行。

提示：

（1）设顺序表中原有数据个数为10个，依次是{1,3,5,7,12,45,67,89,92,99}。

（2）设需要插入的数据x值为25。

（3）注意表长的变化。

（4）有序表的插入，需要分两步完成：

第一步确定插入位置，第二步在插入位置上插入指定的数据。

5.将顺序表（a1，a2，...，an）重新排列为以a1为界的两部分：

a1前面的值均比a1小，a1后面的值都比a1大（这里假设数据元素的类型具有可比性,不妨设为整型）

基本思路：

从第二个元素开始到最后一个元素，逐一向后扫描：

（1）当前数据元素aI比a1大时，表明它已经在a1的后面，不必改变它与a1之间的位置，继续比较下一个。

（2）当前结点若比a1小，说明它应该在a1的前面，此时将它上面的元素都依次向下移动一个位置，然后将它置入最上方。

源程序如下：

#defineMAXSIZE100

#include"stdio.h"

#include"stdlib.h"

typedefintelemtype;

typedefstruct

{elemtypeelem[MAXSIZE];

intlast;

}sqlist;//顺序表结构体类型的定义

sqlist*init_sqlist（）//顺序表的初始化

{sqlist*L;

L=（sqlist*）malloc（sizeof（sqlist））;

L->last=-1;returnL;

}

voidcreatsqlist（sqlist*L）//顺序表的建立

{inti;

printf（"请输入顺序表中最后一个元素的下标\n"）;

scanf（"%d",&（*L）.last）;

printf（"请输入%d个元素\n",L->last+1）;

for（i=0;i<=（*L）.last;i++）

scanf（"%d",&（*L）.elem[i]）;

}

voidpart（sqlist*L）//顺序表的拆分

{inti,j;

elemtypex,y;

x=L->elem[0];/*将基准置入x中*/

for（i=1;i<=L->last;i++）

if（L->elem[i]

{y=L->elem[i];

for（j=i-1;j>=0;j--）/*移动*/

L->elem[j+1]=L->elem[j];

L->elem[0]=y;

}

}

voiddayin（sqlist*a）

{inti;

for（i=0;i<=a->last;i++）

printf（"%d",a->elem[i]）;//顺序表的输出

printf（"\n"）;

}

voidmain（）/*顺序表的主函数*/

{inti;

sqlist*a;

a=init_sqlist（）;//调用函数对顺序表的初始化

creatsqlist（a）;//建立顺序表

printf（"建立的顺序表为：

\n"）;

dayin（a）;//输出顺序表

part（a）;//顺序表的拆分

printf（"拆分后的顺序表为：

\n"）;

dayin（a）;//输出拆分后的线性表

}

6.编写程序从一给定的顺序表A中删除值在x，y（x<=y）之间的所有元素。

提示：

1）方法：

逐一比较每个元素的值，若元素值在X，Y之间，则删除。

2）主函数的编写可模仿第一题

7.编写程序，将给定的顺序表逆置。

例如：

顺序表中的元素为：

247191238

逆置后为：

831291742

**（选做）8.程序阅读题，下列程序是有关顺序表的有关操作，请阅读，然后再上机运行。

#defineLIST_INIT_SIZE8//线性表存储空间的初始分配量

#defineLISTINCREMENT10//线性表存储空间的分配增量

#defineOVERFLOW-2

#defineERROR0

#defineOK1

#defineTRUE1

#defineFALSE0

typedefintStatus;

typedefintElemType;

typedefstruct{

ElemType*elem;//存储空间基址

intlength;//当前长度

intlistsize;//当前分配的存储容量（以sizeof（ElemType）为单位）

}SqList;//俗称顺序表

typedefSqListOdSqList;//有序顺序表

StatusInitList（OdSqList&）;//结构初始化

voidDestroy（OdSqList&）;//销毁有序顺序表

voidClearList（OdSqList&）;//清空有序表

StatusListEmpty（OdSqList）;//判有序表为空

intListLength（OdSqList）;//求表长

intLocateElem（OdSqList,ElemType）;//查找

voidListInsert（OdSqList&,ElemType）;//插入元素

StatusListDelete（OdSqList&,int,ElemType&）;//删除元素

intListDeletem（OdSqList&L,ElemTypee）;

//删除所有值为e的元素,返回删除的元素个数

intListDeletemn（OdSqList&,ElemType,ElemType）;//删除所有值界于mink~maxk的元素，并返回删除的元素个数

voidListTraverse（OdSqList）;//遍历非递减有序线性表

#include

#include

StatusInitList（OdSqList&L）{

//构造一个空的线性表

L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;

if（!

L.elem）

exit（OVERFLOW）;

L.length=0;

L.listsize=LIST_INIT_SIZE;

returnOK;

}//InitList

voidListTraverse（OdSqListL）{

//遍历线性表

inti;

printf（"listsizeis%d.\n",L.listsize）;

printf（"listlengthis%d.\n",L.length）;

printf（"thelistis:

（"）;

for（i=1;i<=L.length;i++）

printf（"%d",L.elem[i-1]）;

printf（"）\n"）;

}

intLocateElem（OdSqListL,ElemTypee）{

//在顺序表中查询第一个满足判定条件的数据元素，若存在，则返回它的位序，否则返回0

inti;

i=1;//i的初值为第1元素的位序

ElemType*p;

p=L.elem;//p的初值为第1元素的存储位置

while（i<=L.length&&*p++!

=e）++i;

if（i<=L.length）returni;

elsereturn0;

}

voidListInsert（OdSqList&L,ElemTypee）{

//在顺序表L中保序插入新的元素e

ElemType*newbase,*p,*q;

if（L.length>=L.listsize）{//当前存储空间已满，增加分配

newbase=（ElemType*）realloc（L.elem,（L.listsize+LISTINCREMENT）*sizeof（ElemType））;

if（!

newbase）exit（OVERFLOW）;//存储分配失败

L.elem=newbase;//新基址

L.listsize+=LISTINCREMENT;//增加存储容量

}

q=&（L.elem[0]）;//q指示第1个元素位置

for（p=&（L.elem[L.length-1]）;p>=q&&*p>e;--p）

*（p+1）=*p;//插入位置及之后的元素右移

*（p+1）=e;//插入e

++L.length;//表长增1

}

StatusListDelete（OdSqList&L,inti,ElemType&e）{

ElemType*p,*q;

if（（i<1）||（i>L.length））returnERROR;//删除位置不合法

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

returnOK;

}

voidDestroy（OdSqList&L）{

//销毁有序顺序表

free（L.elem）;

}

voidClearList（OdSqList&L）{

//清空有序表

L.length=0;

}

StatusListEmpty（OdSqListL）{

//判有序表为空

if（L.length==0）

returnTRUE;

elsereturnFALSE;

}

intListLength（OdSqListL）{

//求表长

returnL.length;

}

intListDeletem（OdSqList&L,ElemTypee）{

//删除所有值为e的元素,返回删除的元素个数

ElemType*p,*q,*r;

inti=0;//删除的元素个数

p=&L.elem[0];//扫描指针

for（q=&L.elem[L.length-1];*p

if（p<=q&&*p==e）{

i++;

for（r=p+1;*r==e&&r<=q;r++,i++）;

if（r<=q）

for（;r<=q;r++,p++）

*p=*r;

}

L.length-=i;

returni;

}

intListDeletemn（OdSqList&L,ElemTypemink,ElemTypemaxk）{

//删除所有值界于mink~maxk的元素，并返回删除的元素个数

ElemType*p,*q,*r,temp;

inti=0;

if（maxk

temp=maxk;

maxk=mink;

mink=temp;

}

p=&L.elem[0];

for（q=&L.elem[L.length-1];*p

//p指针指向第1个大于等于mink的元素

if（p<=q&&*p<=maxk）{//若*p小于等于maxk

i++;

for（r=p+1;*r<=maxk&&r<=q;r++,i++）;//r指针指向第1个大于maxk的元素

if（r<=q）

for（;r<=q;r++,p++）

*p=*r;}

L.length-=i;

returni;

}

voidmain（）{

OdSqListL;

intk;

chari;

ElemTypee,mink,maxk;

printf（"OdSqListisinit……\n"）;

i=InitList（L）;

ListTraverse（L）;

while

（1）{

printf（"\n\npleaseselect:

\n"）;

printf（"1------insert\n"）;

printf（"2------traverse\n"）;

printf（"3------deletei\n"）;

printf（"4------deletek\n"）;

printf（"5------deletemink-maxk\n"）;

printf（"6------locate\n"）;

printf（"7------isempty\n"）;

printf（"8------length\n"）;

printf（"9------clearlist\n"）;

printf（"0------quit\n"）;

scanf（"%d",&k）;

switch（k）{

case1:

printf（"pleaseinpute:

"）;

scanf（"%d",&e）;

ListInsert（L,e）;

ListTraverse（L）;

scanf（"%c",&i）;

printf（"pleasepressanykeytocontinue……"）;

scanf（"%c",&i）;

break;

case2:

ListTraverse（L）;

scanf（"%c",&i）;

printf（"pleasepressanykeytocontinue……"）;

scanf（"%c",&i）;

break;

case3:

while

（1）{

printf（"pleaseinputdeletei:

"）;

scanf（"%d",&i）;

if（ListDelete（L,i,e）==ERROR）

printf（"deletepositoniserror!

\n"）;

else{

printf（"Deletedelemis%d\n",e）;

break;}

}

ListTraverse（L）;

scanf（"%c",&i）;

printf（"pleasepressanykeytocontinue……"）;

scanf（"%c",&i）;

break;

case4:

printf（"pleaseinputdeletee:

"）;

scanf（"%d",&e）;

ListTraverse（L）;

printf（"%delemisdeleted.\n",ListDeletem（L,e））;