数据结构实验课教案文档格式.docx

数据结构实验课教案文档格式.docx

《数据结构实验课教案文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构实验课教案文档格式.docx（114页珍藏版）》请在冰豆网上搜索。

重点

1.线性表的顺序存储的基本算法

难点

请选择你授课时所采用的教学方法（在括号中画“√”）：

讲授法﹝﹞，讨论法﹝﹞，演示法﹝﹞，案例法﹝﹞，发现法﹝﹞，探究法﹝﹞，

谈话法﹝﹞，实验法﹝√﹞，参观法﹝﹞，考察法﹝﹞，自学辅导法﹝﹞，练习

法（习题或操作课）﹝√﹞，读书指导法﹝﹞，听说法﹝﹞，写生法﹝﹞，视唱

法﹝﹞，工序法（技能课）﹝﹞，实习作业法﹝﹞，其他﹝﹞

方法

请选择你授课时所采用的教学手段（在括号中画“√”）：

手段

实物﹝﹞，多媒体﹝﹞，投影﹝﹞，影像﹝﹞，CAI课件﹝﹞，PPT﹝√﹞，标本

﹝﹞，挂图﹝﹞，模型﹝﹞，其他﹝﹞

讨

论、

思考

题、

作业

[

1]李素若，陈万华，游明坤主编.数据结构.北京:

中国水利水电出版社，2014.

2]李素若，陈万华，游明坤主编.数据结构习题集及上机指导.北京:

中国水利水

参考

文献

电出版社，2014.

教学过程及内容

一、实验内容

3

5

6

7

．输入一组整型元素序列，建立顺序表。

．遍历该顺序表。

．在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。

．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。

．判断该顺序表中元素是否对称,对称返回1,否则返回0。

．输入整型元素序列利用有序表插入算法建立一个有序表。

．利用实验6建立两个递增有序表并把它们合并成一个递增有序表。

二、实验指导

1．参考程序为：

voidCreateSqList（SqList*L）

{

intn,i;

do{

printf（"

请输入数据元素的个数:

"

）;

scanf（"

%d"

&

n）;

if（n<

=0）printf（"

输入错误\n"

}

while（n<

=0）;

for（i=0;i<

n;i++）

（L>

elem[i]））;

L>

length=n;

．参考程序为：

voidPrintList（SqListL）

inti;

L.length;i++）

%d"

L.elem[i]）;

\n"

3．参考程序为：

intFindelems（SqListL,ElemTypee）

if（L.elem[i]==e）

return1;

return0;

4．分析：

从顺序表表头开始扫描，当数据元素为偶数时就从该数开始往后查找，一旦

—

1—

找到奇数，则将该偶数与此奇数交换。

顺序表中所有数据全部扫描结束后，所有奇数就排列

在表的前端。

参考程序为：

voidChangeVal（SqList*L）

inti,j,temp;

length;i++）

if（L>

elem[i]%2==0）

for（j=i+1;j<

length;j++）

elem[j]%2!

=0）

temp=L>

elem[i];

elem[i]=L>

elem[j];

elem[j]=temp;

break;

if（j==L>

length）break;

5．参考程序为：

intYesNo_Symmetry（SqListL）

inti,j;

j=L.length1;

j/2;i++）

if（L.elem[i]!

=L.elem[ji]）

voidInsert_OrderList（SqList*L,intx）

elem[i]>

x）break;

for（j=L>

length1;j>

=i;j）

2—

elem[j+1]=L>

elem[i]=x;

length++;

voidCreate_OrderList（SqList*L）

intn,i,input;

input）;

Insert_OrderList（L,input）;

SqList*Merge_OrderList（SqListA,SqListB）

//将有序顺序表A和B合并到有序顺序表C中返回

inti=0,j=0,k=0;

SqList*C=（SqList*）malloc（sizeof（SqList））;

C>

length=0;

while（j<

A.length&

&

k<

B.length）

if（A.elem[j]<

B.elem[k]）

elem[i++]=A.elem[j++];

else

elem[i++]=B.elem[k++];

if（j==A.length）

while（k<

B.length）C>

if（k==B.length）

A.length）C>

length=i;

returnC;

3—

016年9月21日（9

授课进度第4周，第8次课（2学时）

月20日）

（教学章、节实验二单向链表

．掌握线性链表的操作特点，即指针是逻辑关系的映像。

．掌握动态产生单链表的方法。

．熟练掌握单链表的插入、删除操作特点，即指针赋值的先后次序。

1．掌握动态产生单链表的方法。

2．熟练掌握单链表的插入、删除操作特点，即指针赋值的先后次序。

1．熟练掌握单链表的插入、删除操作特点，即指针赋值的先后次序。

．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。

．遍历单向链表。

．把单向链表中元素逆置（不允许申请新的结点空间）。

．在单向链表中删除所有的偶数元素结点。

．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建

立一个非递减有序单向链表。

．利用实验5建立两个递增有序单向链表，然后合并成一个递增链表。

．利用实验1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个

全部为偶数（尽量利用已知的存储空间）。

LinkListCreateListH（void）//头插法产生带头结点单链表

intch;

LinkListhead=（LinkList）malloc（sizeof（LNode））;

LinkLists;

head>

next=NULL;

while（scanf（"

ch）==1）//输入数据类型错误时结束单链表的生成

s=（LinkList）malloc（sizeof（LNode））;

s>

data=ch;

next=head>

next;

next=s;

returnhead;

LinkListCreateListRand（void）//利用随机函数产生带头结点单链表（头插法）

intch,i;

srand（（unsigned）time（NULL））;

PleaseinputCreateNnmbers:

ch）;

ch;i++）

data=rand（）%50;//随机产生0~49之间的数

voidPrintLinkList（LNodeL）

LinkListp;

p=L.next;

while（p）

p>

data）;

p=p>

voidInverse_set（LinkListhead）

LNode*r,*m=NULL,*p;

p=head>

while（p!

=NULL）

r=m;m=p;

m>

next=r;

next=m;

4．参考程序为：

voidDelEvenLinkList（LinkListhead）

LinkListq,p;

q=head;

if（p>

data%2==0）

q>

next=p>

free（p）;

p=q>

q=p;

voidInsertIncr（LinkListhead,ElemTypex）

//将结点插入递增的单链表

LinkListq,p,s;

data=x;

while（p&

p>

data<

x）

next=q>

LinkListCreateListIncr（void）

//通过调用插入有序链表函数生成递增单链表

InsertIncr（head,ch）;

LinkListLinkListCat（LinkListhead1,LinkListhead2）

LinkListh1,h2,h;

h1=head1>

h2=head2>

h=head;

while（h1&

h2）

if（h1>

h2>

data）

h>

next=h1;

h=h>

h1=h1>

next=h2;

h2=h2>

if（h1）h>

if（h2）h>

#

include<

stdio.h>

include<

stdlib.h>

time.h>

typedefintElemType;//元素类型

typedefstructLNode

ElemTypedata;

structLNode*next;

LNode,*LinkList;

4—

voidDecoLinkList（LNodehead,LinkListhead1,LinkListhead2）

//将单链表head拆分奇数链head1和偶数链head2

LinkListh,h1,h2;

h=head.next;

h1=head1;

h2=head2;

while（h）

if（h>

next=h;

h1>

main（）

LinkListhead;

LinkListhead1=（LinkList）malloc（sizeof（LNode））;

LinkListhead2=（LinkList）malloc（sizeof（LNode））;

head=CreateListIncr（）;

PrintLinkList（*head）;

DecoLinkList（*head,head1,head2）;

PrintLinkList（*head1）;

PrintLinkList（*head2）;

5—

016年9月28日（9

授课进度第5周，第10次课（2学时）

月27日）

（教学章、节实验三栈的存储及基本运算

.掌握栈这种数据结构特性及其主要存储结构，并能在现实生活中灵活运用。

.了解和掌握递归程序设计的基本原理和方法。

.掌握栈的两种存储结构

.栈的基本运算

.了解栈在递归函数中的作用

．采用顺序存储实现栈的初始化、入栈、出栈操作。

．采用链式存储实现栈的初始化、入栈、出栈操作。

．写一个程序，将输入的十进制数据M转换为八进制数据M8，将其调试通过。

在此

基础上修改程序，实现十进制数据M向N进制（2或8或16）的转换。

1）采用顺序存储结构实现栈。

2）采用链表结构实现栈。

defineStack_Size100

defineOK

defineERROR

typedefintElemType;

typedefstructStack

ElemTypeelem[Stack_Size];

inttop;

//用来存放栈中元素的一维数组

//用来存放栈顶元素的下标

SqStack;

intInitStack（SqStack**s）//初始化顺序栈

*s）=（SqStack*）malloc（sizeof（SqStack））;

if（（*s）==NULL）returnERROR;

*s）>

top=1;

returnOK;

intEmptyStack（SqStacks）//判断栈空

if（s.top==1）

stackisempty!

returnERROR;

intGetTop（SqStacks,int*e）//取栈顶元算

if（EmptyStack（s））returnERROR;

*e=s.elem[s.top];

intPush（SqStack*s,inte）//入栈

if（s>

top==Stack_Size1）

stackisfull!

top++;

elem[s>

top]=e;

voidPrintStack（SqStacks）//打印栈中数据

=s.top;i++）

s.elem[i]）;

intPop_Stack（SqStack*s,int*e）//出栈

if（EmptyStack（*s））

*e=s>

top];

top;

voidmain（）

intcord,e,x,y;

SqStack*s;

do

\nMainMenu\n"

1CreatStack\n"

2GetTopElement\n"

3Push\n"

4Pop\n"

5Print\n"

6quit\n"

cord）;

switch（cord）

case1:

InitStack（&

s）;

case2:

case3:

if（GetTop（*s,&

y））

StackTop=[%d]\n"

y）;

Pleaseinputpushelement:

e）;

Push（s,e）;

case4:

if（Pop_Stack（s,&

x））

Popstack=[%d]\n"

x）;

case5:

case6:

PrintStack（*s）;

return;

while（cord<

=6）;

typedefstructstacknode

structstacknode*next;

StackNode;

typedefstruct

StackNode*top;/*栈顶指针*/

LinkStack;

voidInitStack（LinkStack*s）//初始化栈

top=NULL;

intEmptyStack（LinkStacks）//判断栈空

if（s.top==NULL）returnOK;

elsereturnERROR;

intGetTop（LinkStacks,int*e）//取栈顶元素

if（EmptyStack（s））returnE