山东建筑大学数据结构课程设计报告.docx

山东建筑大学数据结构课程设计报告.docx

《山东建筑大学数据结构课程设计报告.docx》由会员分享，可在线阅读，更多相关《山东建筑大学数据结构课程设计报告.docx（29页珍藏版）》请在冰豆网上搜索。

山东建筑大学数据结构课程设计报告

山东建筑大学计算机科学与技术学院

课程设计说明书

题目：

基于逆邻接表的有向图基本操作的实现

课程：

数据结构

院（部）：

计算机学院

专业：

计科

班级：

133

学生姓名：

潘含笑

学号：

20131111092

指导教师：

李盛恩

完成日期：

2015.07.03

山东建筑大学计算机科学与技术学院

课程设计任务书

设计题目

基于逆邻接表的有向图基本操作的实现

已知技术参数和设计要求

题目三、实现类NetWork，实现BFS、DFS、拓扑排序，并实现采用逆邻接表作为存储结构的有向图，要继承NetWork。

逆邻接表要使用STL提供的List和Vector等实现。

设计内容与步骤

1、设计存储结构

2、设计算法

3、编写程序，进行调试

4、总结并进行演示、讲解

设计工作计划与进度安排

2015.6.17~2015.6.23，实现基类Network和有向图Graph，实现逆邻接链表的存储结构。

2015.6.23~2015.7.1，编写测试代码。

2015.7.1~2015.7.3，改正一些错误，完成实验。

设计考核要求

1、考勤20%

2、课程设计说明书50%

3、成果展示30%

指导教师（签字）：

教研室主任（签字）

山东建筑大学计算机科学与技术学院

课程设计任务书

设计题目

双向循环链表

已知技术参数和设计要求

实现双向循环链表。

设计内容与步骤

5、设计存储结构

6、设计算法

7、编写程序，进行调试

8、总结并进行演示、讲解

设计工作计划与进度安排

2015.4.22~2015.4.35，实现双向循环链表

2015.4.25~2015.4.29，编写测试代码。

设计考核要求

4、考勤20%

5、课程设计说明书50%

6、成果展示30%

指导教师（签字）：

教研室主任（签字）

逆邻接链表实现有向图

6

一、问题描述

5

二、数据结构

三、逻辑设计

1、总体思路

先实现Network类，通过队列实现BFS，通过堆栈实现DFS和拓扑排序。

再构建Graph类，并继承Network类实现以逆邻接链表为存储结构的有向图。

2、模块划分（以图示的方法给出各个函数的调用关系）

Network类

Initializepos虚函数

Edges虚函数

Begin

虚函数

BFS函数

DFS函数

Topological函数

Deactivatepos虚函数

Vertices虚函数

Nextvertex

虚函数

Begin函数

Out函数

Deactivatepos函数

Initializepos函数

Vertices函数

Edges函数

Nextvertex函数

Graph类

3、函数或类的具体定义和功能

Network类：

virtualintBegin（inti）=0;//确定起始顶点

virtualintNextvertex（inti）=0;//下一个顶点

virtualintEdges（）=0;//确定点

virtualintVertices（）=0;//确定边

virtualvoidInitializepos（inti）=0;//让迭代器等于链表的第i个顶点的第一个元素

virtualvoidDeactivatepos（inti）=0;//删除迭代器指的元素

voidBFS（intv,intreach[],intlabel,inta[]）;//宽度遍历

voidDFS（intv,intreach[],intlabel,inta[]）;//深度遍历

boolTopological（intv[]）;//拓扑排序

virtual~Network（）;//析构函数

Graph类：

virtual~Graph（）;//析构函数

intInDegree（intnode）;//入度

intOutDegree（intnode）;//出度

Graph&Add（intnode1,intnode2）;//添加点

Graph&Delete（intnode1,intnode2）;//删除点

intBegin（inti）;//确定起始顶点

intNextvertex（inti）;//下一个顶点

intEdges（）{returne;}//确定点

intVertices（）{returnn;}//确定边

voidInitializepos（inti）{pos=al[i].begin（）;}////让迭代器等于链表的第i个顶点的第一个元素

voidDeactivatepos（inti）{al[i].erase（pos）;}//删除迭代器指的元素

voidOut（）;//输出函数

四、编码

//Network.h

#include

#include

#include

#include

usingnamespacestd;

classNetwork{

public:

virtualintBegin（inti）=0;

virtualintNextvertex（inti）=0;

virtualintEdges（）=0;

virtualintVertices（）=0;

virtualvoidInitializepos（inti）=0;//让迭代器等于链表的第i点的第一个元素

virtualvoidDeactivatepos（inti）=0;//删除迭代器指的元素

voidBFS（intv,intreach[],intlabel,inta[]）;//宽度遍历

voidDFS（intv,intreach[],intlabel,inta[]）;//深度遍历

boolTopological（intv[]）;//拓扑排序

virtual~Network（）;

};

//Network.cpp

#include"Network.h"

voidNetwork:

:

BFS（intv,intreach[],intlabel,inta[]）

{

intn=Vertices（）;//获取n的值,有几个顶点

queueQ;//创建一个队列

intk=0;//定义一个k来使元素得到保存

reach[v]=label;//标记点

a[k++]=v;//用数组记录BFS的遍历顺序

Q.push（v）;//把一个元素加入队列

while（!

Q.empty（））

{

intx;

x=Q.front（）;//获取队列中的第一个元素

Q.pop（）;//让队列中的第一个元素出队

for（inti=1;i<=n;i++）//寻找x的下一个节点

{

intu=Begin（i）;

if（（u==x）&&（!

reach[i]））//因为是逆邻接链表

{

Q.push（i）;

reach[i]=label;

a[k++]=i;//把标记的元素放入遍历数组

}

while（u）//看后面是不是还有节点

{

u=Nextvertex（i）;

if（（u==x）&&（!

reach[i]））

{

Q.push（i）;

reach[i]=label;

a[k++]=i;

}

}

}

}

for（inti=v;i

{

if（reach[i]==label）

cout<<"执行完BFS后第"<

else

cout<<"执行完BFS后第"<

}

cout<<"从节点"<

for（inti=1;i

{

cout<

};

cout<

}

voidNetwork:

:

DFS（intv,intreach[],intlabel,inta[]）

{

stackS;///创建一个堆栈

intn=Vertices（）;//获取n的值

intk=0;

S.push（v）;//把元素v加入堆栈

while（!

S.empty（））

{

intx=S.top（）;//获取堆栈的栈顶元素

if（!

reach[x]）//如果元素没被标记，就把元素标记

{reach[x]=label;

a[k++]=x;

S.pop（）;//把堆栈的栈顶弹出

for（inti=1;i<=n;i++）//获取节点的下一个元素

{

intu=Begin（i）;

if（（u==x）&&（!

reach[i]））

{

S.push（i）;//把元素加入堆栈

}

while（u）

{

u=Nextvertex（i）;

if（（u==x）&&（!

reach[i]））

{

S.push（i）;

}

}

}

}

else

S.pop（）;//如果被标记元素就弹出

}

for（inti=v;i

{

if（reach[i]==label）

cout<<"执行完DFS后第"<

else

cout<<"执行完DFS后第"<

}

cout<<"从节点1开始DFS遍历的顺序是";

for（inti=1;i

{

cout<

};

cout<

}

boolNetwork:

:

Topological（intv[]）

{

intn=Vertices（）;//获取n的值

vectora（n+1）;

stackS;//创建一个堆栈

for（inti=1;i<=n;i++）//初始化数组a，使每个点的a等于0，用来记录点的入度

a[i]=0;

for（inti=1;i<=n;i++）//遍历整个邻接链表，有入度的节点增加a的值

{

intx=Begin（i）;

while（x）

{

a[i]++;

x=Nextvertex（i）;//后面有元素，则入度加1

}

}

for（inti=1;i<=n;i++）//如果a=0，把元素加入堆栈

if（a[i]==0）S.push（i）;

intk=1;

while（!

S.empty（））

{

inty;

y=S.top（）;//拿出第一个元素

S.pop（）;

v[k++]=y;//弹出获取值的元素

for（inti=1;i<=n;i++）//遍历整个邻接链表，使有y的元素的入度减一

{

intu=Begin（i）;

if（u==y&&a[i]!

=0）

{

a[i]--;

if（a[i]==0）S.push（i）;//如果有入度等于0的元素，把元素加入堆栈

}

while（u）

{

u=Nextvertex（i）;

if（u==y&&a[i]!

=0）

{

a[i]--;

if（a[i]==0）S.push（i）;

}

}

}

}

if（k==n+1）

returntrue;

else

returnfalse;

}

Network:

:

~Network（）{

}

//Graph.h

#include

#include

#include

#include

#include"Network.h"

usingnamespacestd;

classGraph:

publicNetwork{

public:

Graph（int）;

virtual~Graph（）;

intInDegree（intnode）;

intOutDegree（intnode）;

Graph&Add（intnode1,intnode2）;

Graph&Delete（intnode1,intnode2）;

intBegin（inti）;

intNextvertex（inti）;

intEdges（）{returne;}

intVertices（）{returnn;}

voidInitializepos（inti）{pos=al[i].begin（）;}

voidDeactivatepos（inti）{al[i].erase（pos）;}

voidOut（）;

private:

intn;

inte;

vector>al;

list:

:

iteratorpos;

};

//Graph.cpp

#include"Graph.h"

Graph:

:

Graph（intnum）{

e=0;//初始化边，顶点

n=num;

al.resize（n+1）;//开空间

}

Graph:

:

~Graph（）{

}

intGraph:

:

InDegree（intnode）

{

returnal[node].size（）;

}

intGraph:

:

OutDegree（intnode）

{

list:

:

iteratorq;//开链表的迭代器

inti=0;

for（intp=1;p<=n;p++）

{

q=find（al[p].begin（）,al[p].end（）,node）;

if（q!

=al[p].end（））i++;

}

returni;

}

Graph&Graph:

:

Add（intnode1,intnode2）{

if（node1<1||node1>n||node2<1||node2>n）return*this;

list:

:

iteratorp;

p=find（al[node2].begin（）,al[node2].end（）,node1）;//寻找有没有node1

if（p!

=al[node2].end（））return*this;//如果有，返回

else{

al[node2].push_back（node1）;

e++;

}

return*this;

}

Graph&Graph:

:

Delete（intnode1,intnode2）{

if（node1<1||node1>n||node2<1||node2>n）return*this;

list:

:

iteratorp;

p=find（al[node2].begin（）,al[node2].end（）,node1）;

if（p==al[node2].end（））return*this;

else

{

al[node2].erase（p）;//删除要删除的元素

e--;

}

return*this;

}

voidGraph:

:

Out（）{

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

list:

:

iteratorp;

cout<<"逆邻接链表中第"<

for（p=al[i].begin（）;p!

=al[i].end（）;p++）cout<<*p<<'';

cout<

}

return;

}

intGraph:

:

Begin（inti）

{

if（i<1||i>n）cout<<"无该点";

Initializepos（i）;

if（pos==al[i].end（））

return0;

else

return*pos;

}

intGraph:

:

Nextvertex（inti）

{

if（i<1||i>n）cout<<"无该点";

pos++;

if（pos!

=al[i].end（））

return*pos;

else

return0;

}

五、测试数据

#include"Graph.h"

#include"Network.h"

intb[20];

intb1[20];

intc[20];

inta[20];

inta1[20];

intmain（void）

{

intn=6;

intlabel=2;

Graphg（n）;//创建对象

g.Add（1,4）.Add（1,3）.Add（2,4）.Add（2,5）.Add（3,4）.Add（3,6）.Add（4,6）.Add（5,6）;

g.Out（）;

g.BFS（1,b,label,b1）;

cout<

g.DFS（1,a,label,a1）;

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

{

cout<<"节点"<

";

cout<

cout<<"节点"<

";

cout<

}

g.Topological（c）;//执行拓扑排序

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

cout<<"拓扑排序的第"<

cout<

g.Delete（4,6）;

g.Out（）;

}

6、测试情况

双向循环链表

1、问题描述

实现双向循环链表。

二、数据结构

a3

三、逻辑设计

1、总体思路

先构造双向循环链表的节点类，再逐步实现双向循环链表的基本函数。

2、模块划分（以图示的方法给出各个函数的调用关系）

DoubleCircularNode节点类

DoubleCircular类

DoubleCircular类

DoubleCircular类

DoubleCircular类

DoubleCircular类

DoubleCircular类

DoubleCircular类

DoubleCircular类

3、函数或类的具体定义和功能

template

classDoubleCircular{

public:

DoubleCircular（）;//构造函数

~DoubleCircular（）;//析构函数

boolIsEmpty（）const;//判断是否为空

intlength（）const;//计算长度

boolFind（intk,T&x）const;//判断节点是否存在

intSearch（constT&x）const;//查找节点

DoubleCircular&Insert（intk,constT&x）;//插入节点

DoubleCircular&Delete（intk,T&x）;//删除节点

voidOutput（ostream&out）const;//输出函数

private:

DoubleCircularNode*first;

};

四、编码

//DoubleCircular.h

template

classDoubleCircularNode;

#include

usingnamespacestd;

template

classDoubleCircular{

public:

DoubleCircular（）;

~DoubleCircular（）;

boolIsEmpty（）const;

intlength（）const;

boolFind（intk,T&x）const;

intSearch（constT&x）const;

DoubleCircular&Insert（intk,constT&x）;

DoubleCircular&Delete（intk,T&x）;

voidOutput（ostream&out）const;

private:

DoubleCircularNode*first;

};

template

classDoubleCircularNode{

friendclassDoubleCircular;

private:

Tdata;

DoubleCircularNode*left,*right;

};

template

classDoubleCircularIterator{

public:

T*Intialize（constDoubleCircular&c）

{

location=c.first->right;

if（location）

return&location->data;

return0;

}

T*Next（constDoubleCircular&c）

{

if（!

location）return0;

location=location->right;

if（location->right!

=c.first->right）

{

return&location->data;