华北电力大学数据结构实验报告

华北电力大学

实验报告

|

|

实验名称算法与数据结构综合实验

课程名称算法与数据结构

|

|

专业班级：学生姓名：

学号：成绩：

指导教师：实验日期：

（实验报告如打印，纸张用A4，左装订；页边距：上下2.5cm,左2.9cm,

右2.1cm；字体：宋体小四号，1.25倍行距。）

（实验一停车场管理）

（实验二约瑟夫环）

（实验三二叉树的存储及遍历）

（实验四图的存储及遍历）

（实验五哈希表的设计）

一、实验目的及要求

二、所用仪器、设备

三、实验原理

四、实验方法与步骤

五、实验结果与数据处理

六、讨论与结论（对实验现象、实验故障及处理方法、实验中存在的问题等进行分析和讨论，对实验的进一步想法或改进意见）

七、所附实验输出的结果或数据

实验一停车场管理

一、实验内容

设停车场是一个可以停放n辆汽车的狭长通道，且只有一个大门可以供车辆进出。车辆按到达停车场时间的早晚依次从停车场最里向大门口处停放（最先到达的第一辆车放在停车场的最里面）。如果停车场已放满n辆车，则后来的车只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排在便道上的第一辆车就进入停车场。停车场内如有某辆车要开走，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。如果停留在便道上的车未进停车场就要离去，允许其离去，不收停车费，并且仍然保持在便道上等待的车辆次序。编制一程序模拟该停车场的管理。

二、实验目的

掌握栈和队列的定义和实现，学习利用栈和队列解决实际问题。

三、所用仪器、设备

计算机，VC++2010。

四、实验方法与步骤

停车场采用栈式结构，停车场外的便道采用队列结构（即便道就是等候队列）。停车场的管理流程如下：

①当车辆要进入停车场时，检查停车场是否已满，如果未满则车辆进栈（车辆进入停车场）；如果停车场已满，则车辆进入等候队列（车辆进入便道等候）。

②当车辆要求出栈时，该车到栈顶的那些车辆先弹出栈（在它之后进入的车辆必须先退出车场为它让路），再让该车出栈，其他车辆再按原次序进栈（进入车场）。当车辆出栈完毕后，检查等候队列（便道）中是否有车，有车则从队列头取出一辆车压入栈中。

1、用栈模拟停车场，用队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。

2、每次输入完进行输出操作：若是车辆到达，输出汽车在停车场内或便道上的停车位置；若是车辆离去，输出离开的车牌号。

3、其中栈以顺序结构实现，队列以链表结构实现。

详细步骤：

1、定义栈：

typedef struct

{

char data[stacksize];

int top;

}stack;

初始化栈：void Stackinit(stack *x)

void Stackinit(stack *x)

{

int i;

x->top=0;

for(i=0;i<=stacksize;i++)

x->data[x->top]=NULL;

}

2、定义队列：

typedef struct Node

{

char data;

struct Node *next;

}Node;

typedef struct

{

struct Node *head;

struct Node *rear;

}squeue;

初始化队列：int Queueinit(squeue *Q)

int Queueinit(squeue *Q)

{

Q->head=(Node*)malloc(sizeof(Node));

if(Q->head!=NULL)

{

Q->head->next=NULL;

Q->rear=Q->head;

return OK;

}

else

return ERROR;

}

3、处理车辆到达的情况int Arrival(stack *s,squeue *Q)

int Arrival(stack *s,squeue *Q)

{

char p;

Node *t;

cout<<"请输入车牌号:"<

cin>>p;

if(s->top

{

s->top++;

cout<top<<"位置"<

s->data[s->top]=p;

return OK;

}

else

{

cout<

t=(Node*)malloc(sizeof(Node));

t->data=p;

t->next=NULL;

Q->rear->next=t;

Q->rear=t;

return OK;

}

}

处理车辆离开void Leave (stack *s,stack *t,squeue *Q)

void Leave (stack *s,stack *t,squeue *Q)

{

int room;

char p,q;

Node *n;

n=new Node;

if(s->top>0)

{

while(1)

{

cout<<"请输入车在车站中的位置1——"<top<

cin>>room;

if(room>=1&&room<=s->top)

break;

}

while(s->top>room)

{

t->top++;

t->data[t->top]=s->data[s->top];

s->data[s->top]=NULL;

s->top--;

}

p=s->data[s->top];

s->data[s->top]=NULL;

s->top--;

while(t->top>=1)

{

s->top++;

s->data[s->top]=t->data[t->top];

t->data[t->top]=NULL;

t->top--;

}

cout<<"离开车辆的车牌号为："<

if((Q->head!=Q->rear)&&s->top

{

n=Q->head->next;

q=n->data;

s->top++;

cout<<"便道的"<top<<"位置"<

Q->head->next=n->next;

if(n==Q->rear)

Q->rear=Q->head;

s->data[s->top]=q;

delete(n);

}

else

cout<<"便道里没有车！"<

}

else

cout<<"车站里没有车！"<

}

4、主程序void main()

void main()

{

stack s,t;

squeue Q;

int ch;

Stackinit(&s);

Stackinit(&t);

Queueinit(&Q);

while(1)

{

cout<<"1.车辆到达 2.车辆离开 3.退出系统"<

while(1)

{

cin>>ch;

if(ch>=1&&ch<=3)

break;

else

cout<<"请选择：1 2 3."<

}

switch(ch)

{

case 1: Arrival(&s,&Q);

break;

case 2:Leave(&s,&t,&Q);

break;

case 3:exit(0);

default:break;

}

}

system("pause");

}

五、实验结果

1、进入车站：

2、车站已满进入便道：

3、车辆离开：

六、总结与体会

1、虽然实验中遇到了一些问题，但最后在老师的帮助下问题很快就解决了，主要是由于刚开始接触算法不是很熟悉。

2、通过《停车场管理》的实验学习使我基本上理解并学会了用栈的先进后出和队列的先进先出的原理去解决实际问题的思想和方法。但是在编程方面还是很欠缺，还要加强学习。

实验二约瑟夫环

一、实验内容

约瑟夫（Joeph）问题的一种描述是：编号为1,2,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。

二、实验目的

掌握顺序表和链表的定义和实现，学习利用顺序表和链表解决问题。

三、所用仪器、设备

计算机，VC++2010。

四、实验方法与步骤

分析约瑟夫问题：n个人围成圈，提供密码m，从第一个人开始，数到第m个人，删除，从下一个人开始进行第二轮操作，直到所有人都出列。

n个人围圈，形成线性关系；处理为逐个删除，故用链式结构合适；又人员围成圆圈，所以此链式结构采用循环方式较好；排号按照一个方向进行，故数据结构采用带头结点的单向循环链表。假设人员以首次的编号命名，对每个人员采用编号加以描述。利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。

详细步骤：

1、定义约瑟夫环：

typedef struct Node

{

int data;

struct Node *next;

}*circularList;

2、建立约瑟夫环：void CreatList(circularList* head,const int n)

void CreatList(circularList* head,const int n)

{

int i;

Node *p,*q;

q=new Node;

for(i=1;i<=n;i++)

{

p=new Node;

p->data=i;

p->next=NULL;

if(*head==NULL)

{

*head=q=p;

q->next=*head;

}

else

{

p->next=q->next;

q->next=p;

q=p;

}

}

}

3、进行约瑟夫游戏：void Joseph(circularList* head, int t)

void Joseph(circularList* head, int t)

{

Node *p,*q,*b;

b=new Node;

int r=1;

p=q=*head;

while(r)

{

for(int i=1;i<=t;i++)

{

p=q;

q=q->next;

}

if(p==q)

r=0;

b=q;

p->next=q->next;

q=q->next;

cout<<"第"<data<<"个人出列"<

delete(b);

}

head=NULL;

}

4、主程序void main()

void main()

{

circularList head=NULL;

int n,m;

cout<<"请输入总人数n=";

cin>>n;

while(n<=0)

{

cout<<"输入错误！请重新输入！"<

cout<<"请输入总人数n=";

cin>>n;

}

cout<<"请输入m=";

cin>>m;

while(m<=0)

{

cout<<"输入错误！请重新输入！"<

cout<<"请输入m=";

cin>>m;

}

CreatList(&head,n);

cout<<"出列顺序如下："<

Joseph(&head,m-1);

cout<<"约瑟夫环游戏完成！"<

system("pause");

}

五、实验结果

1、输入总人数n

2、输入密码m，进行约瑟夫环游戏

六、总结与体会

1、刚开始对头结点的运用不是很熟悉，通过本次实验加深了我对头结点、链表和顺序表的认识。

2、这次实验相对来说比较简单，但中间也出现了一些错误，在老师的帮助下问题很快就解决了。

3、认识到自己的编程技术还是比较次的，以后一定多多练习。

实验三二叉树的存储及遍历

一、实验内容

1、按先序次序输入二叉树中结点的值，建立一棵以二叉链表作存储结构的二叉树。

2、然后按先序、中序、后序顺序分别遍历这棵二叉树。

二、实验目的

1、树是一种重要的非线性数据结构，要求掌握二叉树的两种基本的存储结构，及各种操作的算法实现（建立、遍历）以及应用。

2、本实验训练的要点是：递归算法的设计方法以及二叉树的应用。

三、所用仪器、设备

计算机，VC++2010。

四、实验方法与步骤

1、编程实现构造一棵二叉树的算法，适合任意合法输入的二叉树的建立。

2、编程实现在二叉链表这种存储方式下，实现二叉的遍历，采用递归实现，遍历算法有先序、中序和后序遍历算法

详细步骤：

1、定义树：

typedef struct btnode

{

char data;

struct btnode *Lchild,*Rchild;

}*Tree;

2、建立二差树：void CreateTree(Tree *t)

void CreateTree(Tree *t)

{

char x;

cout<<"请输入字母："<

cin>>x;

if(x=='#')

*t=NULL;

else

{

*t=(btnode*)malloc(sizeof(btnode));

(*t)->data=x;

CreateTree(&((*t)->Lchild));

CreateTree(&((*t)->Rchild));

}

}

3、先序遍历：void Precorder(Tree t)

void Precorder(Tree t)

{

if(t)

{

cout<data;

Precorder(t->Lchild);

Precorder(t->Rchild);

}

}

4、中序遍历：void Inorder(Tree t)

void Inorder(Tree t)

{

if(t)

{

Inorder(t->Lchild);

cout<data;

Inorder(t->Rchild);

}

}

5、后序遍历：void Postorder(Tree t)

void Postorder(Tree t)

{

if(t)

{

Postorder(t->Lchild);

Postorder(t->Rchild);

cout<data;

}

}

6、主程序：void main()

void main()

{

Tree t;

CreateTree(&t);

cout<<"先序遍历："<

Precorder(t);

cout<

cout<<"中序遍历："<

Inorder(t);

cout<

cout<<"后序遍历："<

Postorder(t);

cout<

system("pause");

}

五、实验结果

1、建立二叉树

2、对二叉树进行遍历

六、总结与体会

1、树状结构中的重点自然是二叉树。对于二叉树的很多操作都是基于对二叉树的遍历，掌握了如何遍历，很多问题也就迎刃而解了，比如对二叉树结点的查找访问、统计二叉树中叶子结点的数目、求二叉树的深度等。

2、 学习算法的目的是利用算法解决实际问题。会写课本上已有的算法之后，可以借其思想进行扩展，逐步提高编程能力。比如数值转换，括号匹配的检验，检验平衡二叉树等。

实验四图的存储及遍历

一、实验内容

1、按次序输入图中结点的值，建立一个以邻接表存储的图。

2、然后分别进行深度优先遍历和广度优先遍历。

二、实验目的

1．熟悉图的两种常用的存储结构，邻接矩阵和邻接表。

2. 建立无向图，用邻接表存储结构存储。

3．在邻接表存储结构上实现深度优先遍历和广度优先遍历。

三、所用仪器、设备

计算机，VC++2010。

四、实验方法与步骤

1、编程实现构造图的算法，适合任意合法输入的无向图的建立。

2、编程实现图在邻接表存储结构存储方式下，实现图的深度优先遍历和广度优先遍历。

详细步骤：

1、定义图的结构：

typedef struct EdgeNode

{

int adjvex;

struct EdgeNode *next;

};

typedef struct Vnode

{

int vertex;

EdgeNode *link;

}Adjlist[MAX];

2、建立图：void build_adjlist(Adjlist *ga)

void build_adjlist(Adjlist *ga)

{

int n,e,i,j;

EdgeNode *p,*q;

cout<<"请输入顶点数:";

cin>>n;

while(n<2)

{

cout<<"请重新输入！"<

cin>>n;

}

for(int m=1;m<=n;m++)

{

ga[m]->link=NULL;

ga[m]->vertex=m;

}

cout<<"请输入边数：";

cin>>e;

for(int k=0;k

{

cout<<"读入顶点对：";

cin>>i;

cin>>j;

p=new EdgeNode;

p->adjvex=j;

p->next=ga[i]->link;

ga[i]->link=p;

q=new EdgeNode;

q->adjvex=i;

q->next=ga[j]->link;

ga[j]->link=q;

}

}

3、深度优先遍历：void dfs(Adjlist *g,int v0,int visited[])

void dfs(Adjlist *g,int v0,int visited[])

{

cout<

visited[v0]=1;

EdgeNode *p;

p=new EdgeNode;

p=g[v0]->link;

while(p!=NULL)

{

if(visited[p->adjvex]==0)

{

dfs(g,p->adjvex,visited);

}

else

p=p->next;

}

}

4、广度优先遍历：void bfs(Adjlist *g,int v0,int visited[])

void bfs(Adjlist *g,int v0,int visited[])

{

int v;

visited[v0]=1;

cout<

EdgeNode *p;

p=new EdgeNode;

p=g[v0]->link;

squeue *q;

q=new squeue;

q->f=q->r=0;

do

{

while(p!=NULL)

{

v=p->adjvex;

if(visited[v]==0)

{

cout<

q->data[q->r]=v;

q->r=q->r+1;

visited[v]=1;

}

p=p->next;

}

if(q->f!=q->r)

{

v=q->data[q->f];

q->f=q->f+1;

p=g[v]->link;

}

}while((p!=NULL)&&(q->f!=q->r));

}

5、主程序：void main()

void main()

{

Adjlist ga;

build_adjlist(&ga);

int visited[MAX];

for(int i=1;i<=MAX;i++)

visited[i]=0;

cout<<"深度优先遍历："<

dfs(&ga,1,visited);

cout<

for(int i=1;i<=MAX;i++)

visited[i]=0;

cout<<"广度优先遍历："<

bfs(&ga,1,visited);

cout<

system ("pause");

}

五、实验结果

1、输入顶点数和边数

2、输入顶点对

3、图的深度优先遍历和广度优先遍历

六、总结与体会

1、本次试验设计内容比较多，虽然实验过程中多次出现问题，但通过老师的帮助和多次调试最终得到解决。

2、通过本次试验，对图的建立有了更深的了解，对书上的代码进行了实现，熟悉并掌握了dfs和bfs算法，对图结构的运用有了进一步的认识。

实验五哈希表的设计

一、实验内容

设计哈希表实现电话号码查询系统。要求实现以下功能：

（1）哈希表中每个记录有下列数据项：电话号码、用户名、地址；

（2）从键盘输入各记录，以电话号码为关键字建立哈希表（至少要有12个以上的记录，哈希表的长度为8）；

（3）采用链地址法解决冲突；

（4）显示建立好的哈希表，并在哈希表上查找、删除和插入给定关键字值得记录。

二、实验目的

1．熟练掌握哈希表的构造方法，深刻理解哈希表与其他结构表的实

质性差别。

2. 建立哈希表，采用除留余数法进行哈希表的散列，即以电话号码作为主关

键字，将电话号码的11位相加，按照模7取余。

3．解决冲突用链地址法。

三、所用仪器、设备

计算机，VC++2010。

四、实验方法与步骤

1、要求输入电话号码、用户名、地址三个信息，并要求分别以电话号码为关键字进行查找，所以本问题要用到一个哈希函数，进行哈希查找。

2、在链地址法中，每个结点对应一个链表结点，它由三个域组成，而由于该程序需要用电话号码为关键字建立哈希表，所以该链表结点它是由四个域组成，name[8] 、num、ads[20]、next 其中num[是为以电话号码为关键字域，存放关键字key；address[20]为结点的数据域，用来存储用户的地址。Next指针是用来指向下一个结点的地址。

详细步骤：

1、定义哈希表的结构：

struct Edgenode

{

char name[8];

double num;

char ads[20];

struct Edgenode *next;

};

typedef struct node

{

int data;

Edgenode *link;

}hashlist[MAX];

2、建立哈希空表：void buildlist(hashlist *h)

void buildlist(hashlist *h)

{

for(int i=0;i

{

h[i]->data=i;

h[i]->link=NULL;

}

}

3、获取关键字key：int keygain(double num)

int keygain(double num)

{

int a,sum=0;

a=num/1000000;

while(a>1)

{

sum+=a%10;

a=a/10;