数据结构之图

图

图的逻辑结构

图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G=(V,E),其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。在线性表和树中，结点个数可以为零，被称为空表和空树；在图中，顶点个数不能为零，但可以没有边。
无向边（Vi，Vj)，有向边<Vi,Vj>

图中基本术语

简单图：在图中，若不存在顶点到其自身的边，且统一条边不重复出现。在数据结构中讨论的都是简单图。
邻接、依附：无向图中，对于任意两个顶点Vi和顶点Vj,若存在边（Vi,Vj)，则称这两个顶点互为邻接点，同时称边（Vi,Vj)依附于这两个顶点。
有向图中，对于任意两个顶点Vi和顶点Vj,若存在边<Vi,Vj>，则称顶点Vi邻接到Vj，顶点Vj邻接自顶点Vi，同时称弧<Vi,Vj>依附于这两个顶点。
线性表、树、图中不同中逻辑关系的对比
在线性结构中，数据元素之间仅具有线性关系；
在树结构中，结点之间具有层次关系；
在图结构中，任意两个顶点之间都可能有关系。
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。
有向完全图：在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。
完全图边数问题：含有n个顶点的无向完全图有nx(n-1)/2条边。含有n个顶点的有向完全图有nx(n-1)条边。
稀疏图、稠密图、顶点的度、顶点的入度、顶点的出度。
总度数为边的两倍，总出度数等于总入度数等于总边数。
权：是指对边赋予的有意义的数值量。
网：边上带权的图，也称网图。
路径：在无向图G=(V, E)中，从顶点vp到顶点vq之间的路径是一个顶点序列(vp=vi0,vi1,vi2, …, vim=vq)，其中，(vij-1,vij)∈E（1≤j≤m）。若G是有向图，则路径也是有方向的，顶点序列满足<vij-1,vij>∈E。
路径长度：非带权图，路径边的个数。带权图，路径中边上权的和。
回路（环）：第一个顶点和最后一个顶点相同的路径。
简单路径：序列中顶点不重复出现的路径。
简单子图：若图G=（V，E），G’=（V’，E’），如果V’V 且E’  E ，则称图G’是G的子图回路（简单环）：除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路。
连通图：在无向图中，如果从一个顶点vi到另一个顶点vj(i≠j)有路径，则称顶点vi和vj是连通的。如果图中任意两个顶点都是连通的，则称该图是连通图。
连通分量：非连通图的极大连通子图称为连通分量。
极大连通子图：1.含有极大顶点数2.依附于这些顶点的所有边。
强连通图：在有向图中，对图中任意一对顶点vi和vj (i≠j)，若从顶点vi到顶点vj和从顶点vj到顶点vi均有路径，则称该有向图是强连通图。
强连通分量：非强连通图的极大强连通子图。
生成树：n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图。
极小连通子图：含有n-1条边，多一条边就构成回路，少一条边就不连通。

图的遍历

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

关键问题

1、如何选取遍历的起始顶点：从编号小的顶点开始。在线性表、树中结点的编号都能由其结构所确定，在图中任何两个顶点之间都可能存在边，顶点是没有确定的先后次序的，所以，顶点的编号不唯一，为了操作方便，将图中的顶点按任意顺序排列起来，比如按顶点的存储顺序。
2、从某个顶点到不了所有顶点怎么办？：多次调用从某个顶点出发遍历图的算法。
3、图中如果出现回路，可能出现死循环怎么办？：设置标志数组。
4、在图中，一个顶点与许多顶点相连，如何选取下一个要访问的顶点呢？：深度优先遍历和广度优先遍历。

深度优先遍历

基本思想：
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
深度优先搜索是带回溯的
栈
许多问题的解决都是通过深度优先搜索方法解决的，例：迷宫问题、骑士巡游问题、八皇后问题、0-1背包问题等等

广度优先遍历

基本思想
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。
队列

图的存储结构及实现

图的特点：顶点之间的关系是m:n，即任何两个顶点之间都可能存在关系（边），无法通过存储位置表示这种任意的逻辑关系，所以，图无法采用顺序存储结构。

邻接矩阵

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

无向图的邻接矩阵

特点：主对角线为0且一定是对称矩阵；
如何求顶点i的度：邻接矩阵的第i行（或第i列）非零元素的个数。如何判断顶点i和j之间是否存在边？：测试邻接矩阵中相应位置的元素是否为1；如何求顶点i的所有邻接点？：将数组中第i行元素扫描一遍，若元素arc[i][j]为1，则顶点j为顶点i的邻接点。

有向图的邻接矩阵

不一定不对称，如有向完全图。
如何求顶点i的出度：邻接矩阵的第i行非零元素的个数。
如何求顶点i的入度：邻接矩阵的第i列非零元素的个数。
如何判断顶点i和j之间是否存在边？：测试邻接矩阵中相应位置的元素是否为1；
对有向图能实现深度优先搜索不能表示有向图连通

图的存储及实现

邻接矩阵

构造函数：

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;  //置有边标志    
    }
}

深度优先遍历

⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
递归定义

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 );
}//时间复杂度N方，应用如迷宫问题

广度优先遍历

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

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;
            }
      }
}

邻接矩阵上的其他操作

增加一个顶点
在存储顶点的一维数组中插入该顶点的信息
在邻接矩阵中插入一行、一列

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; 
 }

删除一个顶点
在存储顶点的一维数组中删除该顶点的信息
在邻接矩阵中删除一行、一列

template <class T>   void MGraph<T>::DeleteVex(int pos){
     if ( pos<0||  pos>MaxSize) throw "位置";   
     int row， col;    
     int numv=vertexNum;    
     for(int i=pos;i<numv;i++)   vertex[i]=vertex[i+1];    
     vertexNum--;                            
     for(row=0;row<numv;row++)   { //删除一列
         for(col=pos;col<numv;col++)	  arc[row][col]=arc[row][col+1];  
    }
    for(row=pos;row<numv;row++) 
	  for(col=0;col<numv;col++)
		  arc[row][col]=arc[row+1][col];      
  } 
}

增加一条边
修改相应的矩阵元素的值

删除一条边
修改相应的矩阵元素的值

邻接表

邻接矩阵存储空间复杂度过高N方，存储稀疏图浪费内存。
邻接表存储的基本思想：
对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）
所有边表的头指针和存储顶点信息的一维数组构成了顶点表。

无向图的邻接表

邻接表的空间复杂度为O（N+e）
如何求顶I的度：该顶点边表中结点的个数。
如何判断顶点i和顶点j之间是否存在边：测试顶点i的边表中是否存在终点为j的结点。

有向图的邻接表（出边表）

如何求顶点i的出度：顶点I 的出边表中结点的个数。
如何求顶点i的入度：各顶点的出边表中以顶点i为终点的结点个数。
如何求顶点Ｉ的所有邻接点？：遍历顶点i的边表，该边表中所有终点都是顶点i的邻接点。
有向图的逆邻接表（入边表）为方便的计算有向图的顶点的入度，可以构造逆邻接表。在逆邻接表中，边表中存储的是以顶点Vi为弧头的狐。
网图就是边带权的图。

邻接表的构造

1. 确定图的顶点个数和边的个数；
2. 输入顶点信息，初始化该顶点的边表；
3. 依次输入边的信息并存储在边表中；
   3.1 输入边所依附的两个顶点的序号i和j；
   3.2 生成邻接点序号为j的边表结点s；
   3.3 将结点s插入到第i个边表的头部；

struct ArcNode{   
      int adjvex; 
      ArcNode *next;
};

template <class T>
struct VertexNode{
      T vertex;
      ArcNode *firstedge;
};

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);//时间复杂度n+e
    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;
       }
    }
}

增删顶点
增加：顶点表中插入一个元素
删除：在顶点表中删除一个元素，同时在边表中删除相应的边
增删边<x, y>
如果是有向图，则在x的边表中增加/删除边；
如果是无向图，则还要在y的边表中增加/删除一条边

图的存储结构之边集数组

利用两个一维数组
一个数组存储顶点信息，
另外一个数组存储边及其权
数组分量包含三个域：边所依附的两个顶点，权值
各边在数组中的次序可以任意。

边集数组的实现

Struct edge
{ 
    int i；
    int j;
    int weight;
}
edge edges[M];//边的数据结构类型的变量
 for ( i = 0; i < G->vexnum; i++) { 
	 for (j = 0; j <= G->vexnum; j++)  {
	    if (G->arc[i][j] == 1)   {//控制条件注意区别有向图，及无向图对重复边的处理。
	  	    edges[k].begin = i;
  	  	    edges[k].end = j;
	          // edges[k].weight = G->arc[i][j];
               k++;
         }
     }

图的连通性-遍历方法的应用

无向图的连通性

要想判定一个无向图是否为连通图，或有几个连通分量，通过对无向图遍历即可得到结果。
连通图：仅需从图中任一顶点出发，进行深度优先搜索（或广度优先搜索），便可访问到图中所有顶点。
非连通图：需从多个顶点出发进行搜索，而每一次从一个新的起始点出发进行搜索过程中得到的顶点访问序列恰为其各个连通分量中的顶点集。
求无向图的连通分量（无向图的遍历方法)
1.count=0;
2. for (图中每个顶点v)
2.1 if (v尚未被访问过)
2.1.1 count++;
2.1.2 从v出发遍历该图（函数调用）；
3. if (count==1) cout<<“图是连通的”;
else cout<<“图中有”<<count<<“个连通分量”;

有向图的连通性