第六章图

最新推荐文章于 2021-06-07 23:50:10 发布

空白__@

最新推荐文章于 2021-06-07 23:50:10 发布

阅读量224

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/qq_43238335/article/details/103273513

版权

C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

第六章图

一、图的逻辑结构

1、图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：

G=(V，E)

其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。

2、如果图的任意两个顶点之间的边都是无向边，则称该图为无向图。否则称为有向图。

3、简单图：在图中，若不存在顶点到其自身的边，且同一条边不重复出现。

4、图的基本术语：

（1）邻接、依附。

（2）顶点的度、入度、出度。

（3）有向完全图、无向完全图。

（4）稠密图、稀疏图。

（5）路径、路径长度、回路。

（6）简单路径、简单回路。

（7）子图。

（8）连通图、连通回路。

（9）强连通图、强连通分量

5、

非带权图——路径上边的个数

带权图——路径上各边的权之和

6、生成树：n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图。

7、图的遍历操作

图的遍历是从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。

在图中，任何两个顶点之间都可能存在边，顶点是没有确定的先后次序的，所以，顶点的编号不唯一。

#深度优先遍历

⑴ 访问顶点v；

⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；

⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

#广度优先遍历

⑴ 访问顶点v；

⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；

⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。

二、图的存储结构及实现

1、

用一个一维数组存储图中顶点的信息

用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。

2、邻接矩阵存储无向图的类

const int MaxSize=10;

template <class T>

class Mgraph{

public:

MGraph(T a[ ], int n, int e );

~MGraph( )

void DFSTraverse(int v);

void BFSTraverse(int v);

……

private:

T vertex[MaxSize];

int arc[MaxSize][MaxSize];

int vertexNum, arcNum;

};

3、构造函数

template <class T>

MGraph::MGraph(T a[ ], int n, int e) {

vertexNum=n; arcNum=e;

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

vertex[i]=a[i];

for (i=0; i<vertexNum; i++) //初始化邻接矩阵

for (j=0; j<vertexNum; j++)

arc[i][j]=0;

for (k=0; k<arcNum; k++) {

cin>>i>>j; //边依附的两个顶点的序号

arc[i][j]=1; arc[j][i]=1; //置有边标志

}

4.深度优先遍历

int visited[MaxSize];

template <class T>

void MGraph::DFSTraverse(int v){

cout<<vertex[v]; visited [v]=1;

for (j=0; j<vertexNum; j++)

if (arc[v][j]==1 && visited[j]==0)

DFSTraverse( j );

}

5.广度优先遍历

int visited[MaxSize];

template <class T>

void MGraph::BFSTraverse(int v){

front=rear=-1; //假设采用顺序队列且不会发生溢出

int Q[MaxSize]; cout<<vertex[v]; visited[v]=1; Q[++rear]=v;

while (front!=rear) {

v=Q[++front];

for (j=0; j<vertexNum; j++)

if (arc[v][j]==1 && visited[j]==0 ) {

cout<<vertex[j]; visited[j]=1; Q[++rear]=j;

}

6、增加一个顶点

template <class T>

void MGraph<T>::InsertVex(int num,T name) {

if ( num<0|| num>vertexNum) throw "位置";

int row, col, numv;

numv = vertexNum-1;

vertexNum++;

for(int i=numv;i>=num;i--) vertex[i++]=vertex[i];

vertex[num]=name;

for(row=numv;row>=0;row--) {所有行上num列之后的列后移，增加一列，

for(col=numv;col>=num;col--) arc[row][col+1]=arc[row][col];

arc[row][num]=0;

}

for(row=numv;row>=num;row--)

for(col=0;col<=numv+1;col++) arc[row+1][col]=arc[row][col];

for(col=0;col<vertexNum;col++) arc[num][col]=0;

}

7、删除一个顶点

template <class T>

void MGraph<T>::InsertVex(int num,T name) {

if ( num<0|| num>vertexNum) throw "位置";

int row, col, numv;

numv = vertexNum-1;

vertexNum++;

for(int i=numv;i>=num;i--) vertex[i++]=vertex[i];

vertex[num]=name;

for(row=numv;row>=0;row--) {所有行上num列之后的列后移，增加一列，

for(col=numv;col>=num;col--) arc[row][col+1]=arc[row][col];

arc[row][num]=0;

}

for(row=numv;row>=num;row--)

for(col=0;col<=numv+1;col++) arc[row+1][col]=arc[row][col];

for(col=0;col<vertexNum;col++) arc[num][col]=0;

}

8、插入一条边

template <class T>

void MGraph<T>::InsertArc(int i, int j)

{

if ( i>MaxSize|| j>MaxSize) throw "位置";

arc[i][j]=1;

arc[j][i]=1;

}

9、邻接表有两种结点结构：顶点表结点和边表结点。

vertex：数据域，存放顶点信息。

firstedge：指针域，指向边表中第一个结点。

adjvex：邻接点域，边的终点在顶点表中的下标。

next：指针域，指向边表中的下一个结点。

struct ArcNode{

int adjvex;

ArcNode *next;

};

template <class T>

struct VertexNode{

T vertex;

ArcNode *firstedge;

};

const int MaxSize=10; //图的最大顶点数

template <class T>

class ALGraph

{

public:

ALGraph(T a[ ], int n, int e);

~ALGraph;

void DFSTraverse(int v);

void BFSTraverse(int v);

………

private:

VertexNode adjlist[MaxSize];

int vertexNum, arcNum;

};

template <class T>

ALGraph::ALGraph(T a[ ], int n, int e)

{

vertexNum=n; arcNum=e;

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

{

adjlist[i].vertex=a[i];

adjlist[i].firstedge=NULL;

}

for (k=0; k<arcNum; k++)

{

cin>>i>>j;

s=new ArcNode; s->adjvex=j;

s->next=adjlist[i].firstedge;

adjlist[i].firstedge=s;

}

template <class T>

void ALGraph::DFSTraverse(int v){

cout<<adjlist[v].vertex; visited[v]=1;

p=adjlist[v].firstedge;

while (p!=NULL) {

j=p->adjvex;

if (visited[j]==0) DFSTraverse(j);

p=p->next;

}

template <class T>

void ALGraph::BFSTraverse(int v){

front=rear=-1;

cout<<adjlist[v].vertex; visited[v]=1; Q[++rear]=v;

while (front!=rear) {

v=Q[++front]; p=adjlist[v].firstedge;

while (p!=NULL) {

j= p->adjvex;

if (visited[j]==0) {

cout<<adjlist[j].vertex; visited[j]=1; Q[++rear]=j;

}

p=p->next;

}

10、利用两个一维数组

一个数组存储顶点信息，
另外一个数组存储边及其权

数组分量包含三个域：边所依附的两个顶点，权值

各边在数组中的次序可以任意。

三、普里姆算法

基本思想：

设G=(V, E)是具有n个顶点的连通网，

T=(U, TE)是G的最小生成树，

T的初始状态为U={u0}（u0∈V），TE={ }，

重复执行下述操作：

在所有u∈U，v∈V-U的边中找一条代价最小的边(u, v)并入集合TE，同时v并入U，直至U=V。

Void prim(MGraph G){

for(int i=1;j<G.vertexNu;i++){

lowcost[i]=G.arc[0][i];adjvex[i]=0;

}

lowcost[0]=0;

for(i=1;i<G.vertexNum;i+++){

k=MinEdge(lowcost,G.vertexNum)

cout<<K<<adjvex[k]<<lowcost[k];

lowcost[k]=0;

for(j=1;j<G.vertexNum;j++)

if((G.arc[k][j]<lowcost[j]){

lowcost[j]=G.arc[k][j];

arcvex[j]=k;

}

四、克鲁斯卡尔算法

思想：

1. 初始化：U=V； TE={ }；

2. 循环直到T中的连通分量个数为1

2.1 在E中寻找最短边(u，v);

2.2 如果顶点u、v位于T的两个不同连通分量，则

2.2.1 将边(u，v)并入TE；

2.2.2 将这两个连通分量合并为一个；

2.3 在E中标记边(u，v)，使得(u，v)不参加后续最短边的选取；

int main(){

int arcNum, int vertexNum;

EdgeNode *edge;

int *parent;

cout<<"please input the number of vertexNum:"; cin>>vertexNum;

cout<<"please input the number of edges:"; cin>>arcNum;

edge=new EdgeNode[arcNum]; parent=new int[vertexNum];

for(int i=0;i<arcNum;i++) {

cout<<"Please input the edges:";

cin>>edge[i].from>>edge[i].to>>edge[i].weight;

}

sort(edges, G); //对边集数组进行堆排序，时间复杂性为O(eloge)

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

parent[i]=-1; //每个节点分属于不同的集合

int k=0,begin,end,count=0;

cout<<"next is the MST :"<<endl;

for (k=0;k<arcNum;k++) {

begin=edge[k].from; end=edge[k].to;

int m,n;

m=Find(parent,begin); n=Find(parent,end);

if(m!=n) {

cout<<begin<<","<<end<<","<<edge[k].weight<<endl;

parent[n]=m;

count++;

if(count==vertexNum-1) break;

}

return 0;

}

int Find(int *parent, int node)

{

int f;

f=node;

while(parent[f]>-1)

f=parent[f];

return f;

}

五、迪杰斯特拉算法—单源点最短路径问题

const int MAX=1000;

void Dijkstra(MGraph g, int v){

for ( i =0; i<g.vexnum ; i++){

dist[i]=g.arcs[v][i];

if ( dist[i]!= MAX)

path [i]=g.vertex[v]+g.vertex[i];

else

path[i]=“”;

}

S[0]=g.vertex[v];

num=1;

While (num<g.vextexNum){

k=0;

for(i=0;i<G.vertexNum;i++)

if((dist[i]<dist[k]) k=i

cout<<dist[k]<<path[k];

s[num++]=G.vertex[k];

for(i=0;i<G.vertexNum;i++)

if(dist[k]+g.arc[k][i]<dist[i] {

dist[i]=dist[k]+g.arc[k][i];

path[i]=path[k]+g.vertex[i];

}

六、弗洛伊德算法—每一对顶点之间的最短路径

void Floyd(MGraph G)

{

for (i=0; i<G.vertexNum; i++)

for (j=0; j<G.vertexNum; j++)

{

dist[i][j]=G.arc[i][j];

if (dist[i][j]!=∞)

path[i][j]=G.vertex[i]+G.vertex[j];

else path[i][j]="";

}

for (k=0; k<G.vertexNum; k++)

for (i=0; i<G.vertexNum; i++)

for (j=0; j<G.vertexNum; j++)

if (dist[i][k]+dist[k][j]<dist[i][j]) {

dist[i][j]=dist[i][k]+dist[k][j];

path[i][j]=path[i][k]+path[k][j];

}

七、AOV网与拓扑排序

AOV网：在一个表示工程的有向图中，用顶点表示活动，用弧表示活动之间的优先关系，称这样的有向图为顶点表示活动的网，简称AOV网。

void TOpSort(){

int top=-1, count=0;

for(int i=0;i<vertexnum;i++)

if(adjlist[i].in==0) s[++top]=i;

while(top!=-1){

j=s[top--]; cout <<adjlist[j].vertext; count++;

p=adjlist[j].firstedge;

while(p!=NULL){

k=p->adjvex; adjlist[k].in--;

if(adjlist[k].in==0) s[top++]=k;

p=p->next;

}

If (count<vertexNum) cout<<“有回路”；

}

八、AOE网与关键路径

在一个表示工程的带权有向图中，用顶点表示事件，用有向边表示活动，边上的权值表示活动的持续时间，称这样的有向图叫做边表示活动的网，简称AOE网。AOE网中没有入边的顶点称为始点（或源点），没有出边的顶点称为终点（或汇点）。

关键路径：在AOE网中，从始点到终点具有最大路径长度（该路径上的各个活动所持续的时间之和）的路径称为关键路径。

关键活动：关键路径上的活动称为关键活动。

要找出关键路径，必须找出关键活动, 即不按期完成就会影响整个工程完成的活动。

首先计算以下与关键活动有关的量：

1.事件的最早发生时间ve[k]

2.事件的最迟发生时间vl[k]

3.活动的最早开始时间e[i]

4.活动的最晚开始时间l[i]

最后计算各个活动的时间余量 l[k] - e[k]，时间余量为0者即为关键活动。

空白__@

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第六章图

第六章图一、图的逻辑结构1、图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为： G=(V，E)其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。2、如果图的任意两个顶点之间的边都是无向边，则称该图为无向图。否则称为有向图。3、简单图：在图中，若不存在顶点到其自身的边，且同一条边不重复出现。...
复制链接

扫一扫

专栏目录

第六章 图

第六章图