数据结构实验报告完整

华北电力大学

实验报告|

|

实验名称数据结构实验

课程名称数据结构

|

|

专业班级：学生姓名：

学号：成绩：

指导教师：实验日期：2015/7/3

实验报告说明：

本次实验报告共包含六个实验，分别为：简易停车场管理、约瑟夫环（基于链表和数组）、二叉树的建立和三种遍历、图的建立和两种遍历、hash-telbook和公司招工系统。

编译环境：visual studio 2010

使用语言：C++

所有程序经调试均能正常运行

实验目录

实验一约瑟夫环（基于链表和数组）

实验二简易停车场管理

实验三二叉树的建立和三种遍历

实验四图的建立和两种遍历

实验五哈希表的设计

实验一：约瑟夫环

一、实验目的

1.熟悉循环链表的定义和有关操作。

二、实验要求

1.认真阅读和掌握实验内容。

2．用循环链表解决约瑟夫问题。

3.输入和运行编出的相关操作的程序。

4.保存程序运行结果 , 并结合输入数据进行分析。

三、所用仪器设备

1.PC机。

2.Microsoft Visual C++运行环境。

四、实验原理

1.约瑟夫问题解决方案：

用两个指针分别指向链表开头和下一个，两指针依次挪动，符合题意就输出结点数据，在调整指针，删掉该结点。

五、代码

1、基于链表

#include

using namespace std;

struct Node

{

int data;

Node* next;

};

void main()

{

int m,n,j=1;

cout<<"请输入m的值：";cin>>m;

cout<<"请输入n的值：";cin>>n;

Node* head=NULL;

Node* s=new Node;

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

{

Node* p=new Node;

p->data=n+1-i;

p->next=head;

head=p;

if(i==1) s=head;

}

Node* p=new Node;

p=head;

s->next=head;

while(p!=s)

{

while(j!=m)

{

p=p->next;

s=s->next;

j++;

}

cout<data;

s->next=p->next;

delete p;

p=s->next;

j=1;

}

cout<data<

delete p;

}

2、基于数组

#include

void main()

{

int m,n,s=0,j=1;

cout<<"请输入m的值：";cin>>m;

cout<<"请输入n的值：";cin>>n;

int *a=new int[n];

for(int i=0;i

a[i]=i+1;

while(n!=0)

{

if(j==m)

{

cout<

j=0;

if(s!=n-1)

{

for(i=s;i

a[i]=a[i+1];

}

n--;

j++;

if(s>n-1) s=0;

}

else

{

j++;

s++;

if(s>n-1)

s=0;

}

}

delete []a;

cout<

}

六、实验结果

1.输入：总人数8；数到 4出列；从第 1人开始；

按照理论应有出队序列：4 8 5 2 1 3 7 6.

2.实验输入输出：

实验二：停车场管理

一、实验目的

1.熟悉栈和队的定义和有关操作。

二、实验要求

1.认真阅读和掌握实验内容。

2．用栈和队解决停车场问题。

3.输入和运行编出的相关操作的程序。

4.保存程序运行结果 , 并结合输入数据进行分析。

三、所用仪器设备

1.PC机。

2.Microsoft Visual C++运行环境。

四、代码

#include

using namespace std;

//栈在这里用顺序结构实现

int N;

int cnum; //定义作为车牌号的变量

struct stack//定义栈

{

int cstack[9999];//这里随便定义一个数字表示数组的长度,因为后面会根据用户输入的N值作为停车场能够停车的数量.

int top;

int size;

};

struct node//定义队列节点的类型

{

int nnum;

node *next;

} ;

struct queue//定义队列

{

node *front,*rear;

};

void initstack(stack *s)//初始化栈

{

s->top=-1;

}

int instack(stack *s,int x)//元素进栈返回值类型为int 这个作为flag使用{ //int 元素进栈n;

if(s->top==N-1)

{

cout<<"停车场已满!车将会停在便道上。"<

return 0;

}

else

{

s->cstack[++(s->top)]=x;

return 1;

}

}

int outstack(stack *s)//元素出栈

{

if(s->top<0)

{

cout<<"目前停车场内一辆车也没有"<

return 0;

}

else

{

s->top--;

return s->cstack[s->top+1]; //帮刚才出栈的那台车的号码返回}

}

void initqueue(queue *q)//初始化队列这里也想写成(*front,*rear)

{

q->front=new node;

q->rear=q->front;

q->front->nnum=0;

q->front->next=NULL;

} //队列初始化要涉及到front和rear指针

void inqueue(queue *q,int num1)//元素进队列

{

node *p=new node;

p->nnum=num1;

p->next=NULL;

q->rear->next=p;

q->rear=p;

q->front->nnum++;

//头结点的数据域放上便道上所停车的辆数

}

int outqueue(queue *q)//元素出队列

{ node* p;

int n;

if(q->front==q->rear)

return 0;

else

{

p=q->front->next;

q->front->next=p->next;

if(p->next==NULL)

q->rear=q->front;

n=p->nnum;

delete p;

q->front->nnum--;

return n;

}

}

void carrival(stack *s,queue *q,int x)//处理车辆到达的情况{

int flag;

flag=instack(s,x); //退出及返回值都正常

if(flag==0) //停车场满

{

inqueue(q,x); // 在主程序部分的确是这个位置****************************

cout<<"车牌号为"<front->nnum<<"号位置."<

}

else

{

cout<<"车牌号为"<top+1<<"号位置."<

}

}

void carleave(stack* s1,stack* s2,queue *q,int x)//处理车辆离开

{

int y;

int a,n=0;

while((s1->top>-1)&&(n==0))

{

y=outstack(s1);

if(y!=x)

{

a=instack(s2,y);

}

else

n=1;

}

if(y==x)

{

cout<<"车牌号为"<

while(s2->top>-1)

{

y=outstack(s2);

n=instack(s1,y);

}

a=outqueue(q);

if(a!=0)

{ y=a;

n=instack(s1,y);

cout<<"车牌号为"<top+1<<"号位置"<

}

}

}

void main()//主程序

{

cout<<">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>"<

cout<<">>>> 欢迎使用停车场程序 >>>>"<

cout<<">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>"<

cout<<"请输入一个数作为作为停车场的最大容车量:"<

cin>>N;//这里N将作为栈能存放元素的数量

while(N<=0)

{

cout<<"输入错误，请再输入:"<

cin>>N;

}

char ch1;

stack *s1,*s2;

queue *q;

int x;

int flag;

s1=new stack;

s2=new stack;

q=new queue;

initstack(s1);

initstack(s2);

initqueue(q);

flag=1;

for(;;)

{

cout<<"车辆是到达(A)还是离开(D)?请输入车辆的牌号："<

cin>>ch1>>x;

switch(ch1)

{

case'A':

case'a':carrival(s1,q,x);

break;

case'D':

case'd':carleave(s1,s2,q,x);

break;

case'E':

case'e':flag=0;cout<<"停车场系统即将关闭"<

break;

default:cout<<"输入错误!!"<

}

cout<

if(flag==0)

break; //对应的系统关闭程序

}

}

五、实验结果

输入N为3

实验三：二叉树的遍历

一、实验目的

1.熟悉二叉树的定义和有关操作。

2.加深理解和认识对二叉树进行遍历的递归算法。

二、实验要求

1.认真阅读和掌握实验内容。

2.对二叉树进行三种遍历。

3.输入和运行给出的二叉树与相关操作的程序。

4.保存程序运行结果 , 并结合输入数据进行分析。

三、所用仪器设备

1.PC机。

2.Microsoft Visual C++运行环境。

四、实验原理

1.先序遍历：（1）访问根结点。

（2）按先序遍历原则遍历左子树。

（3）按先序遍历原则遍历右子树。

2.中序遍历：（1）按中序遍历原则遍历左子树

（2）访问根结点。

（3）按中序遍历原则遍历右子树

3.后序遍历：（1）按后序遍历原则遍历左子树

（2）按后序遍历原则遍历右子树

（3）访问根结点。

五、代码

#include

using namespace std;

struct node

{

int data;

node *Lchild;

node *Rchild;

};

void creatshu(node *nod)

{//建立二叉树

int x,y;

cin>>x; //左子树

if(x==0) nod->Lchild=NULL;

else

{

node *p=new node;

p->data=x;

nod->Lchild=p;

creatshu(nod->Lchild);

}

cin>>y;//右子树

if(y==0) nod->Rchild=NULL;

else

{

node *p=new node;

p->data=y;

nod->Rchild=p;

creatshu(nod->Rchild);

}

}

void preorder(node *nod)

{//前序遍历

if(nod!=NULL)

{

cout<data<<" ";

preorder(nod->Lchild);

preorder(nod->Rchild);

}

}

void inorder(node *nod)

{//中序遍历

if(nod!=NULL)

{

inorder(nod->Lchild);

cout<data<<" ";

inorder(nod->Rchild);

}

}

void postorder(node *nod)

{//后续遍历

if(nod!=NULL)

{

postorder(nod->Lchild);

postorder(nod->Rchild);

cout<data<<" ";

}

}

void main()

{

node *head=new node;//头指针,树根

cout<<"输入树根："<

cin>>head->data;

cout<<"请输入结点(结点为空是输入0，结束也输入0),先建左子树，后建右子树:"<

creatshu(head);

cout<

cout<<"先序为："<

preorder(head);

cout<

cout<<"中序为："<

inorder(head);

cout<

cout<<"后序为："<

postorder(head);

cout<

system("pause");

六、实验结果

1.输入1 2 0 4 0 0 3 5 0 0 6 0 0

按照原理先序遍历应输出：124356

中序遍历应输出：241536

后序遍历应输出：425631

实验四：图的遍历

一、实验目的

1. 熟悉图的邻接表表示。

2. 熟悉对图的邻接表表示分别进行深度和广度优先遍历的算法。

二、实验要求

1. 认真阅读和掌握实验内容。

2. 对图的邻接表表示分别进行深度和广度优先遍历的算法。

3. 输入和运行编出的图与相关操作的程序。

4. 保存程序运行结果 , 并结合输入数据进行分析。

三、所用仪器设备

3.PC机。

4.Microsoft Visual C++运行环境。

四、实验原理

1.图的深度优先遍历（DFS）：

从图的某一点出发，先访问该点的顶点，后选取一个与该点邻接且未被访问过的顶点A，在访问A后，再从A出发进行如上访问，重复此过程，直到某个顶点的所有邻接点都被访问过时，回退到尚有邻接点未被访问过的顶点，再从该顶点出发，重复上述过程，直到所有的被访问过的顶点的邻接点都被访问过，这时遍历结束。

2.图的广度优先遍历（BFS）：

访问图的某一顶点A，从A出发，先访问A的邻接点B1,B2,B3,B4……，然后再顺序访问B1,B2,B3,B4……的所有邻接的尚未访问过的全部顶点，再从这些被访问过的顶点出发，逐次访问与它们连接且未被访问过的顶点。以此类推，直到所有顶点都被访问完为止。

五、代码：

#include

struct Vertex //因为边节点没有权值，所以想用一种同构的结构来简化结构，让程序可读性更高

{

int adjvex;//顶点域

Vertex *next;

int visit;//是否访问过

};

//初始化邻接表

void creat(Vertex v[],int n)

{

int k,i,j;

for(i=0;i

{

v[i].adjvex=i; //给顶点标上序号

}

Vertex *s=NULL;

s=v; //s作为滚动指针，不用分配实际空间for(int i=0;i

{

cout<<"请输入Vertex["<

cin>>k;

if(k!=0)

{

for(j=0;j

{

Vertex *p=new Vertex;

cout<<"请输入和Vertex["<

cin>>p->adjvex;

s->next=p;

s=p;

p->next=NULL; //连接过程

}

}

else v[i].next=NULL;

s=v+i+1; //每给一个顶点初始化完后，要将s指针指向下一个顶点

cout<

}

}

//深度优先搜索

void depth(Vertex v[],int x)

{

cout<

v[x].visit=1;

Vertex *p=new Vertex;

p=v[x].next;

while(p!=NULL)

{

x=p->adjvex;

if(v[x].visit==0)

depth(v,x);

p=p->next;

}

}

//广度优先搜索

void breadth(Vertex v[],int x)

{

cout<

v[x].visit=1;

int f=0; //队列指针

int r=0;

int q[20];

Vertex *p=new Vertex;

p=v[x].next;

do

{

while(p!=NULL)

{

x=p->adjvex;

if(v[x].visit==0)

{

q[r]=x; //入队

r++;

cout<

v[x].visit=1;

}

p=p->next;

}

if(f!=r)

{//v出队

x=q[f];

f++;

p=v[x].next;

}

}while((f!=r) || (p!=NULL)); //书上的算法有问题}

void main(){

int n,x;

cout<<"请输入定点个数：";cin>>n;

Vertex *v=new Vertex[n];

cout<

creat(v,n);

for(int i=0;i

cout<<"请输入深度搜索的开始顶点号：";

cin>>x;

cout<

cout<<"深度优先搜索顺序为：";

depth(v,x);

cout<

for(i=0;i

cout<<"请输入广度搜索的开始顶点号：";

cin>>x;

cout<

cout<<"广度优先搜索顺序为：";

breadth(v,x);