数据结构实验指导书.docx

数据结构实验指导书.docx

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

数据结构实验指导书

《数据结构》课程实验指导书

实验一线性表的顺序存储结构

一、实验类型：

设计性（2课时）

二、实验目的与任务：

掌握顺序存储结构的特点，掌握动态顺序存储结构的常见算法。

三、预习要求：

熟悉C语言中数组的使用，以及动态内存申请与消毁方法

四、实验基本原理：

利用结构体实现动态顺序存储结构，并设计相应函数来解决动态数组的排序等问题。

五、实验仪器与设备：

VC++，WindowsOS

六、实验内容：

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

2．实现该顺序表的遍历。

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

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

4．编写一个主函数,调试上述算法。

七、实验步骤：

1．进入编程环境，建立一新工程；

2.存储定义

structSqList{

int*elem;//动态线性表

intlength;//表的实际长度

intlistsize;

};

3.编译运行程序，观察运行情况和输出结果。

4.参考实验程序，以下几个函数实现了顺序表的创建以及插入和销毁，要求同学们能在此基础上完善其它函数并完成其它实验内容

5.部分源参考源代码

//创建顺序表

voidInitSqlist（SqList&sl）

{

sl.elem=（int*）malloc（100*sizeof（int））;

sl.length=0;

sl.listsize=100;

return;

}

//将元素e插入第i个位置

voidInsertSqlist（SqList&sl,inte,inti）

{

if（i>sl.listsize）

{

printf（"插入位置超过限制！

"）;

return;

}

//表满，重新分配内存

if（sl.length==sl.listsize）

{

sl.elem=（int*）realloc（sl.elem,（sl.listsize+10）*sizeof（int））;

sl.listsize=sl.listsize+10;

sl.elem[i]=e;

}

//表不满，直接插入

if（sl.length

{

if（i>sl.length）

{

sl.elem[i]=e;

}

if（i<=sl.length）

{

for（intk=sl.length;k>=i;k--）

{

sl.elem[k+1]=sl.elem[k];

}

sl.elem[i]=e;

}

}

return;

}

//销毁顺序表

voidFreeSqlist（SqList&sl）

{

free（sl.elem）;

}

八、实验报告要求：

按实验报告本格式填写各项内容，不得缺项。

实验二链式存储结构

（一）----单向链表的有关操作（设计性）

一、实验类型：

设计性（2课时）

二、实验目的与任务：

了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法。

三、预习要求：

单链表的存储结构

四、实验基本原理：

利用结构体定义单链表节点，以及单链表的遍历与插入等，要求自己设计单链表的逆序操作函数

五、实验仪器与设备：

VC++，WindowsOS

六、实验内容：

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

2．遍历单向链表。

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

4．在主函数中调试上述算法。

七、实验步骤

1．进入编程环境，建立一新工程；

2．类型定义

typedefstructLNode

{

intdata;

structLNode*next;

}LNode,*LinkList;

3．为了算法实现简单，最好采用带头结点的单向链表。

4.编译运行程序，观察运行情况和输出结果。

5.部分参考源代码

structNode{

intdata;

Node*next;

};

voidCreateList（Node&list,intn）

{

intk;

Node*l;

l=&list;

for（inti=1;i<=n;i++）

{

scanf（"%d",&k）;

Node*p=newNode;

p->data=k;

p->next=l->next;

l->next=p;

}

}

voidprintlist（Nodelist）

{

Node*l=&list;

l=l->next;

while（l）

{

printf（"%d\n",l->data）;

l=l->next;

}

}

//将单链表进行就地逆置

/*读取一个接点，按前插法插入到链表*/

voidInverseSingleList（Node&List）

{

Node*p,*q;

q=&List;

p=q->next;

while（p）

{

//保存p的下一个接点

q=p->next;

//将p插入到链表的头部

p->next=List.next;

List.next=p;

p=q;

}

}

八、实验报告要求：

按实验报告本格式填写各项内容，不得缺项。

实验三栈和队列（设计性）

一、实验类型：

设计性（2学时）

二、实验目的与任务：

1．掌握栈、队列的思想及其存储实现。

2．掌握栈、队列的常见算法的程序实现。

三、预习要求：

栈和队列的实现原理以及通用存储结构

四、实验基本原理：

栈和队列的实现原理，要求自己设计栈和队列的相关操作。

五、实验仪器与设备：

VC++，WindowsOS

六、实验内容：

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

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

3．在主函数中设计一个简单的菜单，分别测试上述算法。

七、实验步骤：

1．进入编程环境，建立一新文件；

2．类型定义

顺序栈：

#defineMAX100//栈的最大值

typedef　struct

{

int*base；

inttop；

}SqStack；

链栈：

structLstack{

intdata;

Lstack*next;

};

顺序队列：

#defineMAX100//队列的最大长度

typedef　struct

{

int*base；

intfront，rear；

}SqQueue；

3.编译运行程序，观察运行情况和输出结果。

4．部分参考源代码

//队列

typedefstructQNode{

intdata;

structQNode*next;

}QNode,*QueuePtr;

typedefstruct{

QueuePtrfront;

QueuePtrrear;

}LinkQueue;

intInitQueue（LinkQueue&Q）

{

//申请一个节点空间，然后将队头队尾指针指向它

QueuePtrp=（QueuePtr）malloc（sizeof（QNode））;

if（!

p）return0;

Q.front=p;

Q.rear=p;

Q.front->next=NULL;

return1;

}

intCreateQueue（LinkQueue&Q,intn）

{

inti;

QueuePtrs;

if（!

Q.front）return0;

for（i=1;i<=n;i++）

{

//申请一个节点，并初始化其值

s=（QueuePtr）malloc（sizeof（QNode））;

scanf（"%d",&（s->data））;

//插入队列,由于先进先出，所以只能插入到队尾

Q.rear->next=s;

s->next=NULL;

Q.rear=s;

}

return1;

}

//出队，并将出对的元素放到e中

intDeQueue（LinkQueue&Q,int&e）

{

if（Q.front==Q.rear）return0;

//取出队头指针的数据

QueuePtrp=Q.front->next;

e=p->data;

Q.front=Q.front->next;

if（Q.rear==p）

Q.rear=Q.front;

free（p）;

}

intPrintQueue（LinkQueueQ）

{

QueuePtrp=Q.front->next;

while（p）

{

printf（"%d\n",p->data）;

p=p->next;

}

return1;

}

八、实验报告要求：

按实验报告本格式填写各项内容，不得缺项。

实验四二叉树的操作（设计性）

一、实验类型：

设计性（4学时）

二、实验目的与任务：

1．掌握二叉树的存储实现。

2．掌握二叉树的遍历思想。

3．掌握二叉树的常见算法的程序实现。

三、预习要求：

二叉树的存储结构以及二叉树的遍历

四、实验基本原理：

二叉树的递归遍历和非遍历思想。

五、实验仪器与设备：

VC++，WindowsOS

六、实验内容：

1.输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F###建立二

叉树，实现先序、中序和后序以及按层次遍历序列。

2.要求自己设计一个函数，求二叉树的所有叶子及结点总数。

七、实验步骤：

1．进入编程环境，建立一新文件；

2.采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作；

3.求所有叶子及结点总数的操作；

4.编译运行程序，观察运行情况和输出结果。

5.部分参考源代码

typedefstructNode

{

chardata;

structNode*LChild;

structNode*RChild;

}BiTNode,*BiTree;

//按先序序列建立二叉树

voidCreateBiTree1（BiTree&bt）

{

charch;

scanf（"%c",&ch）;

getchar（）;

if（ch==''）

{

bt=NULL;

printf（"不产生子树!

"）;

}

else

{

bt=（BiTree）malloc（sizeof（Node））;

bt->data=ch;

printf（"产生左子树!

"）;

CreateBiTree1（bt->LChild）;

printf（"产生右子树!

"）;

CreateBiTree1（bt->RChild）;

}

return;

}

voidVisit（charch）

{

printf（"%c",ch）;

}

/*先序遍历二叉树,root为指向二叉树（或某一子树）根结点的指针*/

voidPreOrder（BiTreeroot）

{

if（root!

=NULL）

{

Visit（root->data）;/*访问根结点*/

PreOrder（root->LChild）;/*先序遍历左子树*/

PreOrder（root->RChild）;/*先序遍历右子树*/

}

}

/*中序遍历二叉树,root为指向二叉树（或某一子树）根结点的指针*/

voidInOrder（BiTreeroot）

{

if（root!

=NULL）

{

InOrder（root->LChild）;/*中序遍历左子树*/

Visit（root->data）;/*访问根结点*/

InOrder（root->RChild）;/*中序遍历右子树*/

}

}

/*后序遍历二叉树，root为指向二叉树（或某一子树）根结点的指针*/

voidPostOrder（BiTreeroot）

{

if（root!

=NULL）

{

PostOrder（root->LChild）;/*后序遍历左子树*/

PostOrder（root->RChild）;/*后序遍历右子树*/

Visit（root->data）;/*访问根结点*/

}

}

voidzhonginorder（BiTreeroot）/*中序遍历二叉树，root为二叉树的根结点*/

{

inttop=0;

BiTreep;

BiTrees[30];

intm;

m=29;

p=root;

do

{

while（p!

=NULL）

{

if（top>m）return;

top=top+1;

s[top]=p;

p=p->LChild;

};/*遍历左子树*/

if（top!

=0）

{

p=s[top];

top=top-1;

Visit（p->data）;/*访问根结点*/

p=p->RChild;/*遍历右子树*/

}

}while（p!

=NULL||top!

=0）;

}

八、实验报告要求：

按实验报告本格式填写各项内容，不得缺项。

实验五图的遍历操作（综合性）

一、实验类型：

综合性（2学时）

二、实验目的与任务：

掌握有向图和无向图的概念；掌握邻接矩阵和邻接链表建立图的存储结构；掌握DFS、BFS的基本思想及对图的遍历操作；了解图结构在人工智能、工程等领域的广泛应用。

三、预习要求：

图的存储结构以及图的遍历操作

四、实验基本原理：

综合运用图的相关知识以及DFS、BFS的基本思想，解决图的关键路径以及最短路径等工程知识。

五、实验仪器与设备：

VC++，WindowsOS

六、实验内容：

设计一个有向图和一个无向图，用邻接矩阵作为存储结构，完成有向图和无向图的DFS（深度优先遍历）和BFS（广度优先遍历）的操作。

七、实验步骤：

1．进入编程环境，建立一新文件；

2.采用邻接矩阵和邻接链表作为图的存储结构，完成有向图和无向图的DFS和BFS

操作；

3.编译运行程序，观察运行情况和输出结果。

4.部分参考源代码

#defineMaxVertexNum5

#definem5

#defineNULL0

typedefstructnode

{intadjvex;

structnode*next;

}JD;

typedefstructtnode

{

intvexdata;

JD*firstarc;

}TD;

typedefstruct

{

TDag[m];

intn;

}ALGRAPH;

voidDFS（ALGRAPH*G,inti）;

voidcreat（ALGRAPH*G）

{

inti,m1,j;

JD*p,*p1;

printf（"pleaseinputthenumberofgraph\n"）;

scanf（"%d",&G->n）;

for（i=0;in;i++）

{

printf（"pleaseinputtheinfoofnode%d",i）;

scanf（"%d",&G->ag[i].vexdata）;

printf（"pleaseinputthenumberofarcswhichadjto%d",i）;

scanf（"%d",&m1）;

printf（"pleaseinputtheadjvexpositionofthefirstarc\n"）;

p=（JD*）malloc（sizeof（JD））;

scanf（"%d",&p->adjvex）;

p->next=NULL;

G->ag[i].firstarc=p;

p1=p;

for（j=2;j<=m1;j++）

{

printf（"pleaseinputthepositionofthenextarcvexdata\n"）;

p=（JD*）malloc（sizeof（JD））;

scanf（"%d",&p->adjvex）;

p->next=NULL;

p1->next=p;

p1=p;

}

}

}

intvisited[MaxVertexNum];

voidDFSTraverse（ALGRAPH*G）

{

inti;

for（i=0;in;i++）

visited[i]=0;

for（i=0;in;i++）

if（!

visited[i]）

DFS（G,i）;

}/*DFSTraverse*/

voidDFS（ALGRAPH*G,inti）{

JD*p;

printf（"visitvertex:

%d->",G->ag[i].vexdata）;

visited[i]=1;/*标记vi已访问*/

p=G->ag[i].firstarc;/*取vi边表的头指针*/

while（p）{/*依次搜索vi的邻接点vj，这里j=p->adjvex*/

if（!

visited[p->adjvex]）/*若vi尚未被访问*/

DFS（G,p->adjvex）;/*则以Vj为出发点向纵深搜索*/

p=p->next;

}

}/*DFS*/

main（）

{

ALGRAPH*G;

printf（"下面以临接表存储一个图；\n"）;

creat（G）;

printf（"下面以深度优先遍历该图\n"）;

DFSTraverse（G）;

getch（）;

}

八、实验报告要求：

按实验报告本格式填写各项内容，不得缺项。

实验六查找（综合性）

实验目的：

掌握顺序查找、折半查找及二叉排序树上查找的基本思想和算法实现，了解怎样对各种查找方法进行时间性能（平均查找长度）分析。

二、实验内容：

1、设计一组有序数据和一组随机数据输入，分别对线性表进行折半查找和顺序查找，比较它们的查找速度。

2、将（45，24，55，12，37，53，60，28，40，70）中关键字依次插入初态为空的二叉排序树中，给出树的先序序列。

三、实验要求：

1.根据实验内容编程，上机调试、得出正确的运行程序。

2.写出实验报告（包括源程序和运行结果）。

四、实验学时：

2学时

五、实验仪器与设备：

VC++，WindowsOS

五、实验步骤：

1．进入编程环境，建立一新文件；

2.编程输入数据，输出查找结果；

3.输入数据输出所得到的二叉排序树。

七、部分参考源代码

#defineM500

//索引结点

typedefstruct

{intkey;

intlink;

}SD;

typedefstruct

{

intkey;

floatinfo;

}JD;

//分块查找，k为要查找的关键字

intblocksrch（JDr[],SDnd[],intb,intk,intn）

{

inti=1,j;

while（（k>nd[i].key）&&（i<=b））

i++;

if（i>b）

{

printf（"\nNotfound"）;

return（0）;

}

j=nd[i].link;

while（（j

=r[j].key）&&（r[j].key<=nd[i].key））

j++;

if（k!

=r[j].key）

{

j=0;

printf（"\nNotfound"）;

}

return（j）;

}

//折半查找

intbinsrch（JDr[],intn,intk）

{

intlow,high,mid,found;

low=1;

high=n;

found=0;

while（（low<=high）&&（found==0））

{

mid=（low+high）/2;

if（k>r[mid].key）

low=mid+1;

elseif（k==r[mid].key）

found=1;

else

high=mid-1;

}

if（found==1）

return（mid）;

else

return（0）;

}

//顺序查找

intseqsrch（JDr[],intn,intk）

{

inti=n;

r[0].key=k;

while（r[i].key!

=k）

i--;

return（i）;

}

八、实验报告要求：

按实验报告本格式填写各项内容，不得缺项。

实验七排序（设计性）

四、实验目的：

掌握各种排序方法的基本思想、排序过程、算法实现，能进行时间和空间性能的分析，根据实际问题的特点和要求选择合适的排序方法。

二、实验内容：

1.实现直接排序、冒泡、直接选择、快速排序算法。

2任意输入关键字序列，采用不同的排序方法进行排序。

三、实验要求：

1.根据实验内容编程；

2.比较各种算法的运行速度。

（计算各种算法的速度，要用到头文件time.h中的time（）和difftime（）两个函数

#include

time_tt1,t2;

doublett1;

t1=time（NULL）;

t2=time（NULL）;

tt1=difftime（t2,t1）//tt1记录两次截取的系统时间之差

3.上机调试、得出正确的运行程序。

4.写出实验报告（包括源程序和运行结果）。

五、实验仪器与设备：

VC++，WindowsOS

四、实验学时：

2学时

五、实验步骤：

1．进入编程环境，建立一新文件；

2.编译运行程序，观察运行情况和输出结果。

六、选作实验

设计一个程序，任意给出n个学生信息（包括：

学号，姓名，成绩等），实现按照分数高低打印出学生的考试名次、学号、姓名和成绩，同一名次的学生按照学号有效到大排序。

七、部分参考源代码

voidprint（intr[],intn）

{

inti;

for（