数据结构实验指导书网络工程10.docx

数据结构实验指导书网络工程10.docx

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

数据结构实验指导书网络工程10

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

适用于网络工程10级

指导教师：

向华政

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

一、实验类型：

设计性

二、实验目的与任务：

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

三、预习要求：

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

四、实验基本原理：

四、实验内容：

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

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

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

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

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

三、实验要求：

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

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

四、实验学时：

2学时

五、实验步骤：

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

2.存储定义

structSqList{

int*elem;//动态线性表

intlength;//表的实际长度

intlistsize;

};

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

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

//创建顺序表

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

}

实验二链式存储结构

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

一、实验目的：

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

二、实验内容：

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

2．遍历单向链表。

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

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

三、实验要求：

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

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

四、实验学时：

2学时

五、实验步骤：

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

2．类型定义

typedefstructLNode

{

intdata;

structLNode*next;

}LNode,*LinkList;

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

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

六、选作实验

建立一个有序单向链表。

并在有序链表中插入一个元素使链表元素仍有序。

七、部分参考源代码

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;

}

}

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

一、实验目的：

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

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

二、实验内容：

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

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

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

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

三、实验要求：

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

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

四、实验学时：

2学时

五、实验步骤：

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

2．类型定义

顺序栈：

#defineMAX100//栈的最大值

typedef　struct

{

int*base；

inttop；

}SqStack；

链栈：

structLstack{

intdata;

Lstack*next;

};

顺序队列：

#defineMAX100//队列的最大长度

typedef　struct

{

int*base；

intfront，rear；

}SqQueue；

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

六、选作实验

1.实现循环队列的建立、出队、入队操作。

2.编写程序判断读入的字符系列是否为“回文”（正读和反读都相同的字符系列）。

要求：

同时用栈和队列，将输入的元素分别进栈和进队列，然后退栈和出队，若两者

出来的顺序相同则是“回文”。

七、部分参考源代码

//队列

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;

}

实验四二叉树的操作（综合性）

一、实验目的：

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

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

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

二、实验内容：

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

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

2.求所有叶子及结点总数。

二、实验要求：

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

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

四、实验学时：

4学时

五、实验步骤：

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

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

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

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

六、选作实验

给定权值5,29,7,8,14,23,3,11，建立哈夫曼树，输出哈夫曼编码。

七、部分参考源代码

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

}

实验五图的遍历操作（设计性）

一、实验目的：

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

二、实验内容：

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

三、实验要求：

1.根据实验内容编程，画出你所设计的图，写出两种方法的遍历序列。

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

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

四、实验学时：

2学时

五、实验步骤：

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

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

操作；

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

七、部分参考源代码

#defineMAX_VERTEX_NUM20

//有向图的十字链表存储表示

//定义弧信息

typedefstructArcBox{

inttailvex,headvex;//该弧的尾顶点和头顶点的位置；

structArcBox*hlink,*tlink;//弧头相同和弧尾相同的链域

//InfoType*info;

}ArcBox;

//定义顶点信息

typedefstructVexNode

{

intdata;//存顶点有关信息

structArcBox*firstin;//指向以该顶点为弧头的第一个弧结点

structArcBox*firstout;//指向以该顶点为弧尾的第一个弧结点

}DD;

//定义图的结构

typedefstruct{

DDxlist[MAX_VERTEX_NUM];//表头向量,顶点向量

intvexnum,arcnum;//顶点数目和弧的数目

}OLGraph;

//输入n个顶点的信息和e条弧的信息，建立该有向图的十字链表

intCreateDG（OLGraph&G）

{

//输入顶点的数目，弧的数目

printf（"请输入顶点的数目和弧的数目\n"）;

scanf（"%d%d",&G.vexnum,&G.arcnum）;

//构造表头向量

printf（"请输入各个顶点的数据\n"）;

for（inti=0;i

{

scanf（"%d",&G.xlist[i].data）;

G.xlist[i].firstin=NULL;//初始化指向弧的指针

G.xlist[i].firstout=NULL;

}

//输入各弧并构造十字链表

intArcStart,ArcEnd;

for（i=0;i

{

//输入一条弧的起点和终点,注意终点为弧头

printf（"请输入弧的起点和终点\n"）;

scanf（"%d%d",&ArcStart,&ArcEnd）;

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

p->headvex=ArcEnd;

p->tailvex=ArcStart;

p->hlink=G.xlist[ArcEnd].firstin;//弧头相同的链域

p->tlink=G.xlist[ArcStart].firstout;//弧尾相同的链域

G.xlist[ArcEnd].firstin=G.xlist[ArcStart].firstout=p;//两个顶点的相应链域指针位置后移

}

return1;

}

intvisited[MAX_VERTEX_NUM];

voidDFS（OLGraphg,intv）

{

visited[v]=1;

intk;

printf（"%d",v）;

ArcBox*arc=g.xlist[v].firstout;

while（arc）

{

k=arc->headvex;

if（!

visited[k]）

{

DFS（g,k）;

}

arc=g.xlist[k].firstout;

if（visited[arc->headvex]）break;

}

//for（）

}

voidDFSTraverse（OLGraphg）

{

for（inti=0;i

visited[i]=0;

for（i=0;i

{

if（!

visited[i]）

DFS（g,i）;

}

}

实验六查找（综合性）

一、实验目的：

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

二、实验内容：

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

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

三、实验要求：

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

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

四、实验学时：

2学时

五、实验步骤：

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.写出实验报告（包括源程序和运行结果）。

四、实验学时：

2学时

五、实验步骤：

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

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

六、选作实验

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

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