图的基本操作与实现Word格式文档下载.docx

图的基本操作与实现Word格式文档下载.docx

《图的基本操作与实现Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《图的基本操作与实现Word格式文档下载.docx（31页珍藏版）》请在冰豆网上搜索。

对于带权图，结点中还要保存该边的权值cost。

通过在顶点表的第i个顶点信息中保存的指针adj，可以找到与顶点i对应的边链表的第一个边结点；

此外，该记录还保存有该顶点的其他信息。

1.3.2图的深度优先搜索

深度优先搜索是个不断探查和回溯的过程。

在探查的每一步，算法都有一个当前顶点。

最初的当前顶点，也就是指定的起始顶点。

每一步探查过程中，首先对当前顶点v进行访问，并立即设置该顶点的访问标志visited[v]=true。

接着在v的所有邻接顶点中，找出尚未访问过的一个，将其作为下一步探查的当前顶点。

倘若当前顶点的所有邻接顶点都已经被访问过，则退回一步，将前一步所访问的顶点重新取出，当作探查的当前顶点。

重复上述过程，直到最初指定起始顶点的所有邻接顶点都被访问到，此时连通图中的所有顶点也必然都被访问过了。

1.3.3图的广度优先搜索

广度优先搜索时一个逐层遍历的过程，在此过程中，图中有多少顶点就要重复多少步。

每一步都有一个当前顶点。

最初的当前顶点是主过程指定的起始顶点。

在每一步中，首先访问当前顶点v，并设置该顶点的访问标志visited[v]=true。

接着依次访问v的各个未曾被访问过的邻接顶点w1，w2，…，wt，然后再顺序访问w1，w2，…，wt的所有还未被访问过的邻接顶点。

再从这些访问过的顶点出发，再访问它们的所有还未被访问过的邻接顶点，如此做下去，直到图中所有顶点都被访问为止。

2概要设计

2.1程序的整体功能结构

输入1个图先求出每个顶点的度,输出结果；

然后指定任意顶点x为初始顶点,对图G作DFS遍历,输出DFS顶点序列；

接着指定任意顶点x为初始顶点,对图G作BFS遍历,输出BFS顶点序列；

其次输入顶点x,查找图G:

下一步是判断图G是否是连通图，输出信息“YES”/“NO”；

最后如果选用的存储结构是邻接矩阵,则用邻接矩阵的信息生成图G的邻接表,即复制图G,然再执行操作

（2）；

反之亦然。

2.2数据结构的设计

2.2.1边节点类的定义

structEdge//边结点的定义

{

intdest;

//边的另一顶点位置

Ecost;

//边上的权值

Edge<

T,E>

*link;

//下一条边链指针

};

2.2.2顶点类的定义

template<

classT,classE>

//顶点的定义

structVertex

Tdata;

//顶点的名字

Edge<

*adj;

//边链表的头指针

2.2.3图类的定义

classGraph//图的类定义

{

protected:

intmaxVertices;

//图中最大的顶点数

intnumEdges;

//当前边数

intnumVertices;

//当前顶点数

T*output;

//存放遍历的数组

T*input;

//存放输入数组

Vertex<

*NodeTable;

//顶点表（各边链表的头结点）

intgetVertexPos（constTvertx）//取顶点v在数组中的位置

{

intj=-1;

for（inti=0;

i<

numVertices;

i++）

{

if（NodeTable[i].data==vertx）

j=i;

}

returnj;

}

voidDFS（Graph<

&

G,intv,boolvisited[]）//图的深度优先搜索

cout<

<

G.getValue（v）<

'

'

;

//访问顶点v

visited[v]=true;

//作访问标记

intw=G.getFirstNeighbor（v）;

//第一个邻接顶点

while（w!

=-1）//若邻接顶点w存在

{

if（!

visited[w]）

DFS（G,w,visited）;

//若w未访问过,递归访问顶点w

w=G.getNextNeighbor（v,w）;

//下一个邻接顶点

public:

Graph（）;

//构造函数

~Graph（）;

//析构函数

TgetValue（inti）//取顶点i的值

{

return（i>

=0&

i<

numVertices）?

NodeTable[i].data:

0;

boolinsertVertex（constT&

vertex）;

//插入顶点vertex

boolinsertEdge（intv1,intv2,Ecost）;

//插入边（v1,v2）,权值为cost

boolremoveVertex（intv）;

//删除指定的顶点

boolremoveEdge（intv1,intv2）;

//删除一条边

intgetFirstNeighbor（intv）;

//取顶点v的第一个邻接顶点

intgetNextNeighbor（intv,intw）;

//取v的邻接顶点w的下一邻接顶点

intgetFirstCost（intv）;

//取顶点v的第一个邻接顶点的cost值

intgetNextCost（intv,intw）;

//取v的邻接顶点w的下一邻接顶点的cost值

voidDFS（Graph<

G,constT&

v）;

//从顶点v出发对图G进行深度优先遍历的主过程

intBFS（Graph<

T,E>

G,constT&

//图的广度优先搜索

voidWheCan（Graph<

G）;

//判断是否为连通图

voidOutPut（）;

//输出

voidHaveEdge（Graph<

//求顶点的度

voidSerachVertex（Graph<

//输入顶点x,查找图G:

若存在含x的顶点,则删除该结点及与之相关连的边,并作DFS遍历

voidChangeGraph（Graph<

//将用邻接表表示的数转换为邻接矩阵表示

voidInput（）;

//输入

3详细设计和实现

3.1算法流程图

程序主要设计了六个功能：

首先是求每个顶点的度，然后可以选择对图G作DFS（或BFS）搜索，接着可以判断此图是否连通，接着可以将图G转换为临街矩阵存储方式退出，最后可以对图G作查找顶点。

主函数流程如下：

图3.1.1主函数流程图

3.2各个要求的实现方法

3.2.1自选存储结构,输入含n个顶点（用字符表示顶点）和e条边的图G

采用邻接表的存储结构

N个顶点的输入存储到顶点节点链表（Vertex）中

如果第n个节点和第m个节点之间含有一条边e，就将n和m的顶点链表中指向的边链表中存储入n和m在顶点表中的下标和权值

3.2.2求每个顶点的度,输出结果

顶点的度指与该顶点相关联的边的条数

在用邻接链表做为图的存储方式中，要求一个顶点n的度只要去搜索存放顶点n的边节点链表，其中存放了多少条边的信息，这个顶点的度就为多少。

3.2.3指定任意顶点x为初始顶点,对图G作DFS遍历,输出DFS顶点序列

DFS遍历指的是深度优先搜索

深度优先搜索的基本思想：

DFS在访问图中某一起始顶点v后,由v出发,访问它的任一邻接顶点w1;

再从w1出发,访问与w1邻接但还没有访问过的顶点w2;

然后再从w2出发,进行类似的访问,…如此进行下去,直至到达所有的邻接顶点都被访问过的顶点u为止。

接着,退回一步,退到前一次刚访问过的顶点,看是否还有其它没有被访问的邻接顶点。

如果有,则访问此顶点,之后再从此顶点出发,进行与前述类似的访问;

如果没有,就再退回一步进行搜索。

重复上述过程,直到连通图中所有顶点都被访问过为止。

3.2.4指定任意顶点x为初始顶点,对图G作BFS遍历,输出BFS顶点序列

BFS指的是广度优先搜索

BFS基本思想：

BFS在访问了起始顶点v之后,由v出发,依次访问v的各个未被访问过的邻接顶点w1,w2,…,wt,然后再顺序访问w1,w2,…,wt的所有还未被访问过的邻接顶点。

再从这些访问过的顶点出发，再访问它们的所有还未被访问过的邻接顶点，…如此做下去，直到图中所有顶点都被访问到为止。

广度优先搜索是一种分层的搜索过程,每向前走一步可能访问一批顶点,不像深度优先搜索那样有往回退的情况。

因此,广度优先搜索不是一个递归的过程。

3.2.5输入顶点x,查找图G:

输入顶点，在顶点表中所搜是否含有这个顶点，如果没有，就输出“无x”。

如果含有，搜索存放顶点n的边节点链表，找出其中存放的顶点m，然后将这个顶点m链表中的存放n的那个节点删除，同时将n中存放m的节点删除。

然后在顶点链表中存放顶点n的节点删除。

3.2.6判断图G是否是连通图，输出信息“YES”/“NO”；

对图做BFS遍历，如果遍历到的顶点数等于当前的顶点数的个数，这个图就是联通图，反之就不是连通图

3.2.7如果选用的存储结构是邻接矩阵,则用邻接矩阵的信息生成图G的邻接表,即复制图G,然再执行操作

（2）；

反之亦然

我采用的是邻接矩阵做为图的存储结构。

将用邻接表存储的图转化为邻接矩阵的存储的基本思想是：

（1）将图的顶点表中存放的顶点的信息都存放在一个顶点矩阵中

（2）逐个搜索各个顶点的边节点链表，如果含有节点，将邻接矩阵中对应二维数组的值赋值为cost的值。

顶点的度为：

统计第i行（列）不为0的个数可得顶点i的度。

3.3主程序设计

///////////////////////////////////////////////////Graph.h

#include<

iostream>

stdlib.h>

#include"

Queue.h"

usingnamespacestd;

intdest;

Ecost;

Edge（）{}//构造函数

Edge（intnum,Ecost）:

dest（num）,weight（cost）,link（NULL）{}//构造函数

booloperator!

=（Edge<

R）const//判边等否

{

returndest!

=R.dest;

Tdata;

Edge<

Graph<

:

Graph（）//构造函数：

建立一个空的邻接表

{

maxVertices=100;

numVertices=0;

numEdges=0;

NodeTable=newVertex<

[maxVertices];

//创建顶点表数组

if（NodeTable==NULL）

cerr<

"

存储分配错!

endl;

exit

（1）;

for（inti=0;

maxVertices;

i++）

NodeTable[i].adj=NULL;

output=newT[maxVertices];

}

~Graph（）//析构函数：

删除一个邻接表

*p=NodeTable[i].adj;

while（p!

=NULL）

{

NodeTable[i].adj=p->

link;

deletep;

p=NodeTable[i].adj;

}

delete[]NodeTable;

//删除顶点表数组

boolGraph<

insertVertex（constT&

vertex）//插入顶点

if（numVertices==maxVertices）

returnfalse;

NodeTable[numVertices].data=vertex;

numVertices++;

returntrue;

template<

classT,classE>

insertEdge（intv1,intv2,Ecost）//插入边（v1,v2）,权值为cost

if（v1>

=0&

v1<

=numVertices&

v2>

v2<

=numVertices）

*q,*p=NodeTable[v1].adj;

//v1对应的边链表头z指针

while（p!

=NULL&

p->

dest!

=v2）//寻找邻接顶点v2

p=p->

if（p!

=NULL）//找到此边不插入

returnfalse;

p=newEdge<

//否则创建新节点

q=newEdge<

p->

dest=v2;

cost=cost;

link=NodeTable[v1].adj;

//链入v1的边链表

NodeTable[v1].adj=p;

q->

dest=v1;

link=NodeTable[v2].adj;

//链入v2的边链表

NodeTable[v2].adj=q;

numEdges++;

returntrue;

else

参数有误!

请重新输入!

removeVertex（intv）

if（numVertices==1||v<

0||v>

参数有误，请重新输入！

//表空或顶点超出范围

*p,*s,*t;

intk;

while（NodeTable[v].adj!

=NULL）

p=NodeTable[v].adj;

k=p->

dest;

s=NodeTable[k].adj;

t=NULL;

while（s!

s->

=v）

t=s;

s=s->

if（s!

if（t==NULL）

NodeTable[k].adj=s->

else

t->

link=s->

deletes;

NodeTable[v].adj=p->

deletep;

numEdges--;

numVertices--;

NodeTable[v].data=NodeTable[numVertices].data;

p=NodeTable[v].adj=NodeTable[numVertices].adj;

while（p!

s=NodeTable[p->

dest].adj;

if（s->

dest==numVertices）

{

s->

dest=v;

break;

}

s=s->

removeEdge（intv1,intv2）

if（v1!

=-1&

v2!

=-1）

*p=NodeTable[v1].adj,*q=NULL,*s=p;

des