数据结构与算法与实践数据结构实践实验指导书参考.docx

数据结构与算法与实践数据结构实践实验指导书参考.docx

《数据结构与算法与实践数据结构实践实验指导书参考.docx》由会员分享，可在线阅读，更多相关《数据结构与算法与实践数据结构实践实验指导书参考.docx（67页珍藏版）》请在冰豆网上搜索。

数据结构与算法与实践数据结构实践实验指导书参考

《数据结构实践》

实验指导书

2013年8月

实验一C语言编程复习

一、实验目的

1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。

2.理解指针与应用的区别。

3.掌握结构体的使用。

4.掌握简单排序方法。

二、实验内容

1、使用指针和引用两种方式，完成两个学生的交换。

2、写一函数，根据成绩，对包含有n个学生的数组进行排序。

三、实验步骤

1.定义一个Student的结构体类型，包含学号、姓名、成绩等成员。

2.分别写Swap1（Student*s1,Student*s2）和Swap2（Student&s1,Student&s2），完成两个学生的交换。

3.写一排序函数SortStu（Student*s,intn），使用冒泡或者简单选择排序算法根据成绩完成学生的排序。

四、实现提示

structStudent

{

charname[20];//姓名

charnum[10];//学号

floatscore;//成绩

};

voidSwap1（Student*,Student*）;//交换两个结构体变量（指针）

voidSwap2（Student&,Student&）;//交换两个结构体变量（引用）

voidSortStu（Student*,int）;//按成绩（高到低）排序

五、思考与提高

思考为何voidSwap1（Student,Student）这个函数无法实现两个学生的交换？

六、完整参考程序

voidSwap1（Student*s1,Student*s2）

{

Studenttemp;

temp=*s1;

*s1=*s2;

*s2=temp;

}

voidSwap2（Student&s1,Student&s2）

{

STUDENTtemp;

temp=s1;

s1=s2;

s2=temp;

}

voidSortStu（StudentS[],intn）

{

Studenttemp;

for（inti=0;i

{

intidx=i;

for（intj=i+1;j

{

if（S[idx].score>S[j].score）

idx=j;

}

if（idx!

=i）

{

temp=S[idx];

S[idx]=S[i];

S[i]=temp;

}

}

}

实验二线形表基本操作的实现

一、实验目的

1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。

2.掌握线性表的顺序存储结构的定义及C语言实现。

3.掌握线性表的链式存储结构——单链表的定义及C语言实现。

4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。

5.掌握线性表在链式存储结构——单链表中的各种基本操作。

二、实验内容

1.顺序线性表的建立、插入及删除。

2.链式线性表的建立、插入及删除。

三、实验步骤

1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

2.利用前面的实验先建立一个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插入元素68。

3.建立一个带头结点的单链表，结点的值域为整型数据。

要求将用户输入的数据按尾插入法来建立相应单链表。

四、实现提示

1.由于C语言的数组类型也有随机存取的特点，一维数组的机内表示就是顺序结构。

因此，可用C语言的一维数组实现线性表的顺序存储。

在此，我们利用C语言的结构体类型定义顺序表：

#defineMAXSIZE 1024

typedef int elemtype;   /* 线性表中存放整型元素 */

typedefstruct

{elemtypevec[MAXSIZE];

 intlen;            /* 顺序表的长度 */

 }sequenlist;

将此结构定义放在一个头文件sqlist.h里，可避免在后面的参考程序中代码重复书写，另外在该头文件里给出顺序表的建立及常量的定义。

2.注意如何取到第i个元素，在插入过程中注意溢出情况以及数组的下标与位序（顺序表中元素的次序）的区别。

3.单链表的结点结构除数据域外，还含有一个指针域。

用C语言描述结点结构如下：

   typedefintelemtype;

typedefstructnode

   {elemtypedata;  //数据域

     structnode*next;//指针域

    }linklist;

   注意结点的建立方法及构造新结点时指针的变化。

构造一个结点需用到C语言的标准函数malloc（），如给指针变量p分配一个结点的地址：

p=（linklist*）malloc（sizeof（linklist））;该语句的功能是申请分配一个类型为linklist的结点的地址空间，并将首地址存入指针变量p中。

当结点不需要时可以用标准函数free（p）释放结点存储空间，这时p为空值（NULL）。

五、思考与提高

1.如果按由表尾至表头的次序输入数据元素，应如何建立顺序表。

2.在main函数里如果去掉L=&a语句，会出现什么结果？

六、完整参考程序

#include

#include

#defineMAX30//定义线性表的最大长度

enumBOOL{False,True};//定义BOOL型

typedefstruct{

charelem[MAX];//线性表

intlast;//last指示当前线性表的长度

}sqlist;

voidinitial（sqlist&）;//初始化线性表

BOOLinsert（sqlist&,int,char）;//在线性表中插入元素

BOOLdel（sqlist&,int,char&）;//在线性表中删除元素

intlocate（sqlist,char）;//在线性表中定位元素

voidprint（sqlist）;//显示线性表中所有元素

voidmain（）

{sqlistS;//S为一线性表

intloc,flag=1;

charj,ch;

BOOLtemp;

printf（"本程序用来实现顺序结构的线性表。

\n"）;

printf（"可以实现查找、插入、删除等操作。

\n"）;

initial（S）;//初始化线性表

while（flag）

{printf（"请选择:

\n"）;

printf（"1.显示所有元素\n"）;

printf（"2.插入一个元素\n"）;

printf（"3.删除一个元素\n"）;

printf（"4.查找一个元素\n"）;

printf（"5.退出程序\n"）;

scanf（"%c",&j）;

switch（j）

{case'1':

print（S）;break;//显示所有元素

case'2':

{printf（"请输入要插入的元素（一个字符）和插入位置:

\n"）;

printf（"格式：

字符，位置；例如:

a,2\n"）;

scanf（"%c,%d",&ch,&loc）;//输入要插入的元素和插入的位置

temp=insert（S,loc,ch）;//插入

if（temp==False）printf（"插入失败!

\n"）;//插入失败

else{printf（"插入成功!

\n"）;print（S）;}//插入成功

break;

}

case'3':

{printf（"请输入要删除元素的位置:

"）;

scanf（"%d",&loc）;//输入要删除的元素的位置

temp=del（S,loc,ch）;//删除

if（temp==True）printf（"删除了一个元素:

%c\n",ch）;//删除成功

elseprintf（"该元素不存在!

\n"）;//删除失败

print（S）;

break;

}

case'4':

{printf（"请输入要查找的元素:

"）;

scanf（"%c",&ch）;//输入要查找的元素

loc=locate（S,ch）;//定位

if（loc!

=-1）printf（"该元素所在位置:

%d\n",loc+1）;//显示该元素位置

elseprintf（"%c不存在!

\n",ch）;//当前元素不存在

break;

}

default:

flag=0;printf（"程序结束，按任意键退出!

\n"）;

}

}

getch（）;

}

voidinitial（sqlist&v）

{//初始化线性表

inti;

printf（"请输入初始线性表长度：

n="）;//输入线性表初始化时的长度

scanf（"%d",&v.last）;

printf（"请输入从1到%d的各元素（字符），例如:

abcdefg\n",v.last）;

getchar（）;

for（i=0;i

}

BOOLinsert（sqlist&v,intloc,charch）

{//插入一个元素，成功返回True，失败返回False

inti;

if（（loc<1）||（loc>v.last+1））

{printf（"插入位置不合理!

\n"）;//位置不合理

returnFalse;

}

elseif（v.last>=MAX）//线性表已满

{printf（"线性表已满!

\n"）;

returnFalse;

}

else{for（i=v.last-1;i>=loc-1;i--）v.elem[i+1]=v.elem[i];//其后元素依次后移

v.elem[loc-1]=ch;//插入元素

v.last++;//线性表长度加一

returnTrue;

}

}

BOOLdel（sqlist&v,intloc,char&ch）

{//删除一个元素，成功返回True，并用ch返回该元素值，失败返回False

intj;

if（loc<1||loc>v.last）//删除位置不合理

returnFalse;

else{ch=v.elem[loc-1];//ch取得该元素值

for（j=loc-1;j

v.last--;//线性表长度减一

returnTrue;

}

}

intlocate（sqlistv,charch）

{//在线性表中查找ch的位置，成功返回其位置，失败返回-1

inti=0;

while（i

=ch）i++;//当前位置后移，直到找到为止

if（v.elem[i]==ch）//找到当前元素

returni;

elsereturn（-1）;

}

voidprint（sqlistv）//显示当前线性表所有元素

{inti;

for（i=0;i

printf（"\n"）;

}

2.链式线性表的建立、插入及删除。

#include

#include

#include

#defineLENsizeof（LNode）//定义LEN为一个节点的长度

enumBOOL{False,True};//定义BOOL型

typedefstructnode

{chardata;//数据域

structnode*next;//指向下一个节点的指针

}LNode,*LinkList;

voidCreatList（LinkList&,int）;//生成一个单链表

BOOLListInsert（LinkList&,int,char）;//在单链表中插入一个元素

BOOLListDelete（LinkList&,int,char&）;//在单链表中删除一个元素

BOOLListFind_keyword（LinkList,char,int&）;//按关键字查找一个元素

BOOLListFind_order（LinkList,char&,int）;//按序号查找一个元素

voidListPrint（LinkList）;//显示单链表所有元素

voidmain（）

{LinkListL;

BOOLtemp;

intnum,loc,flag=1;

charj,ch;

printf（"本程序实现链式结构的线性表的操作。

\n"）;

printf（"可以进行插入，删除，定位，查找等操作。

\n"）;

printf（"请输入初始时链表长度:

"）;//输入生成单链表时的元素个数

scanf（"%d",&num）;

CreatList（L,num）;//生成单链表

ListPrint（L）;

while（flag）

{printf（"请选择:

\n"）;

printf（"1.显示所有元素\n"）;//显示链表元素

printf（"2.插入一个元素\n"）;//插入链表元素

printf（"3.删除一个元素\n"）;//删除链表元素

printf（"4.按关键字查找元素\n"）;//按关键字查找

printf（"5.按序号查找元素\n"）;//按序号查找

printf（"6.退出程序\n"）;//退出

scanf（"%c",&j）;

switch（j）

{case'1':

ListPrint（L）;break;

case'2':

{printf（"请输入元素（一个字符）和要插入的位置:

\n"）;

printf（"格式:

字符，位置；例如:

a,3\n"）;

scanf（"%c,%d",&ch,&loc）;//输入要插入的元素和要插入的位置

temp=ListInsert（L,loc,ch）;//插入

if（temp==False）printf（"插入失败!

\n"）;//插入失败

elseprintf（"插入成功!

\n"）;//成功插入

ListPrint（L）;

break;

}

case'3':

printf（"请输入要删除的元素所在位置:

"）;

scanf（"%d",&loc）;//输入要删除的节点的位置

temp=ListDelete（L,loc,ch）;//删除

if（temp==False）printf（"删除失败!

\n"）;//删除失败

elseprintf（"成功删除了一个元素:

%c\n",ch）;//删除成功，显示该元素

ListPrint（L）;

break;

case'4':

if（L->next==NULL）//链表为空

printf（"链表为空!

\n"）;

else{printf（"请输入要查找的元素（一个字符）:

"）;

scanf（"%c",&ch）;//输入要查找的元素

temp=ListFind_keyword（L,ch,loc）;//按关键字查找

if（temp==False）printf（"没有找到该元素!

\n"）;//查找失败

elseprintf（"该元素在链表的第%d个位置。

\n",loc）;

//成功查找，显示该元素位置

}

break;

case'5':

if（L->next==NULL）//链表为空

printf（"链表为空!

\n"）;

else{printf（"请输入要查找的位置:

"）;

scanf（"%d",&loc）;//输入要查找的元素的位置

temp=ListFind_order（L,ch,loc）;//按序号查找

if（temp==False）printf（"该位置不存在!

\n"）;//查找失败

elseprintf（"第%d个元素是：

%c\n",loc,ch）;

//成功查找，显示该元素

}

break;

default:

flag=0;printf（"程序结束，按任意键退出!

\n"）;

}

}

getch（）;

}

voidCreatList（LinkList&v,intn）

{//生成一个带头结点的有n个元素的单链表

inti;

LinkListp;

v=（LinkList）malloc（LEN）;//生成头结点

v->next=NULL;

printf（"请输入%d个字符：

例如：

abcdefg\n",n）;

getchar（）;

for（i=n;i>0;--i）

{p=（LinkList）malloc（LEN）;//生成新结点

scanf（"%c",&p->data）;

p->next=v->next;

v->next=p;

}

}

BOOLListInsert（LinkList&v,inti,chare）

{//在单链表的第i各位置插入元素e，成功返回True，失败返回False

LinkListp,s;

intj=0;

p=v;

while（p&&jnext;++j;}//查找第i-1个元素的位置

if（!

p||j>i-1）returnFalse;//没有找到

s=（LinkList）malloc（LEN）;//生成一个新结点

s->data=e;

s->next=p->next;//将新结点插入到单链表中

p->next=s;

returnTrue;

}

BOOLListDelete（LinkList&v,inti,char&e）

{//在单链表中删除第i个元素，成功删除返回True，并用e返回该元素值，失败返回False

LinkListp,q;

intj=0;

p=v;

while（p->next&&j

{p=p->next;++j;}

if（!

（p->next）||j>i-1）returnFalse;//查找失败

q=p->next;p->next=q->next;//删除该元素

e=q->data;//e取得该元素值

free（q）;//释放该元素空间

returnTrue;

}

BOOLListFind_keyword（LinkListv,chare,int&i）

{//在单链表中查找关键字为e的元素，成功返回True,并用i返回该元素位置，

//失败返回False

i=1;

LinkListp;

p=v->next;

while（（p->data!

=e）&&（p->next!

=NULL））//p指针指向下一个，直到

{p=p->next;i++;}//找到或到链表尾为止

if（p->data!

=e）//该元素在链表中不存在

returnFalse;

elsereturnTrue;

}

BOOLListFind_order（LinkListv,char&e,inti）

{//在单链表中查找第i个元素，成功返回True，并用e返回该元素值，

//失败返回False

LinkListp;

intj=0;

p=v;

while（p->next&&j

{p=p->next;++j;}

if（j!

=i）returnFalse;//查找失败

else{e=p->data;//查找成功，用e取得该元素值

returnTrue;

}

}

voidListPrint（LinkListv）

{//显示链表所有元素

LinkListq;

q=v->next;

printf（"链表所有元素:

"）;

while（q!

=NULL）

{printf（"%c",q->data）;q=q->next;}

printf（"\n"）;

}

实验三栈和队列基本操作的实现及应用

一、实验目的

1.掌握栈的顺序表示和实现

2.掌握队列的链式表示和实现

二、实验内容

1.编写一个程序实现顺序栈的各种基本运算。

2.实现队列的链式表示和实现。

三、实验步骤

1.初始化顺序栈

2.插入元素

3.删除栈顶元素

4.取栈顶元素

5.遍历顺序栈

6.置空顺序栈

7.初始化并建立链队列

8.入链队列

9.出链队列

10.遍历链队列

四、实现提示

1./*定义顺序栈的存储结构*/

typedefstruct{

    ElemTypestack[MAXNUM];

    inttop;

}SqStack;

/*初始化顺序栈函数*/

voidInitStack（SqStack*p）

{q=（SqStack*）malloc（sizeof（SqStack）/*申请空间*/）

/*入栈函数*/

voidPush（SqStack*p,ElemTypex）

{if（p->top

    {p->top=p->top+1;    /*栈顶+1*/

     p->stack[p->top]=x;} /*数据入栈*/

}

/*出栈函数*/

ElemTypePop（SqStack*p）

{x=p->stack[p->top];/*将栈顶元素赋给x*/

p->top=p->top-1;}/*栈顶-1*/

/*获取栈顶元素函数*/

ElemTypeGetTop（SqStack*p）

{x=p->stack[p->top];}

/*遍历顺序栈函数*/

voidOutStack（SqStack*p）

{for（i=p->top;i>=0;i--）

printf（"第%d个数据元素是：

%6d\n",i,p->stack[i]）;}

/*置空顺序栈函数*/

voidsetEmpty（SqStack*p）

{p->top=-1;}

2./*定义链队列*/

typedefstructQnode

{  ElemTypedata;

    structQnode*next;

}Qnodetype;