图

最新推荐文章于 2023-03-24 09:39:28 发布

竭尽全力*无怨无悔

最新推荐文章于 2023-03-24 09:39:28 发布

阅读量161

点赞数

本文链接：https://blog.csdn.net/qq_43633207/article/details/103281902

版权

第六章图

总框架

图思维导图
本章的主要内容是:
图的逻辑结构
图的存储结构及实现
图的连通性
最小生成树
最短路径
AOV网与拓扑排序
AOE网与关键路径
一、图的逻辑结构

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;

           }

    }

}

四、克鲁斯卡尔算法

思想：

初始化：U=V； TE={ }；
循环直到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者即为关键活动。