数据结构-图

图

图的表示（图的存储）

1. 邻接表 adjacent list
2. 邻接矩阵 adjacent matrix
3. 关联矩阵 incidence matrix

/**无向图的定义：利用邻接表
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */

图的搜索算法

From Wiki

广度优先搜索BFS

• Prim的最小生成树算法
• Dijkstra的单元最短路径算法
• 广度优先搜索的过程将构造出一颗广度优先树
• 广度优先搜索的性质
  
  • BFS可以正确计算出最短路径距离。
  • BFS过程所生成的前驱子图是一颗广度优先树。
  • 给定图G(V,E)，G为一个有向图或无向图，设s∈V为任意顶点，则对于任意边(u,v)E, ��(s,v)≤��(s,u)+1。/注释：��表示最短路径，u为v的前驱顶点/
  • 设G=(V,E)为一个有向图或无向图，假定BFS以给定顶点s∈V作为源结点在图G上运行。那么在BFS终结时，对于每个顶点v∈V,BFS锁计算出的v.d满足v.d≥��(s,v)。
  • 设G=(V,E)为一个有向图或无向图，又假设BFS以s为源顶点在图G上运行。那么在算法执行过程红，BFS将发现从源顶点s可以到达的所有顶点v∈V，并在算法终止时，对于所有的v∈V，vv.d=��(s,v)。而且，对于任意可以从s到达的顶点v≠s，从源顶点s到顶点v的其中一条最短路径为从顶点s到顶点v.π（v的前驱顶点）的最短路径再加上边(v.π,v)。

深度优先搜索DFS

• 深度优先搜索的过程将构造出一颗深度优先森林
• DFS的应用
  
  • 拓扑排序：Topological Sort
  • 检测是否有环
  • 对于无权图，DFS遍历生成最小生成树
  • 找寻路径
  • 查找强连通分量
    算法实现：
• Breadth First Traversal for a Graph
• Depth First Traversal for a Graph
• DFS and BFS Algorithms using Stacks and Queues

//从给定顶点输出图中BFS的搜索顺序
//只输出能够从源顶点到达的顶点
#include<iostream>
#include <list>
#include <vector>
#include <queue>
using namespace std;

/*使用邻接表构建图类
* @ V：定点个数
* @ adj：邻接边
* @ Graph(int V)：图类构造函数
* @ void addEdge(int v, int w)：添加边
* @ void BFS(int s)：对给定的源顶点进行BFS搜索
* @ void DFS(int v)：DFS搜索
* @ void DFS2(int v)：DFS非递归实现
*/
class Graph{
    int V;
    list<int> *adj; 
    void DFSUtil(int v,vector<bool> &visited); //供DFS调用
public:
    Graph(int V);
    void addEdge(int v, int w);
    void BFS(int s); 
    void DFS(int v);
    void DFS2(int v);
}; 
Graph::Graph(int V){
    this->V = V;
    adj = new list<int>[V];
} 
void Graph::addEdge(int v, int w){
    adj[v].push_back(w);
}
void Graph::BFS(int s){   
    vector<bool> visited(V,false);//避免有环图中的结点不断地被搜索
    queue<int> Q;//使用FIFO的队列管理被搜索的顶点
    visited[s] = true;
    Q.push(s);    
    list<int>::iterator i;//i用来遍历每个顶点所属的边

    while(!Q.empty()){
        s = Q.front();
        cout << s << " ";
        Q.pop();
        for(i = adj[s].begin(); i != adj[s].end(); ++i){
            if(!visited[*i]){
                visited[*i] = true;
                Q.push(*i);
            }
        }
    }
}
void Graph::DFSUtil(int v, vector<bool> &visited){
    visited[v] = true;
    cout << v << " "; 
    list<int>::iterator i;
    for (i = adj[v].begin(); i != adj[v].end(); ++i)
        if (!visited[*i])
            DFSUtil(*i, visited);
} 
// DFS遍历（对可到达的顶点进行遍历）调用DFSUtil
void Graph::DFS(int v){
    vector<bool> visited(V,false);
    DFSUtil(v, visited);
}
//使用stack非递归算法实现DFS
void Graph::DFS2(int v){
    vector<bool> visited(V,false);
    stack<int> s;
    s.push(v);
    while(!s.empty()){
        int u=s.pop();
        if(!visited[u]){
            visited[u]=true;
            for(auto w: adj[u])
                s.push(w);
        }
    }
}
//测试用例
int main(){
    //构造图
    Graph g(4);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(2, 0);
    g.addEdge(2, 3);
    g.addEdge(3, 3);

    cout << "Following is BFS (starting from vertex 2) \n";
    g.BFS(2);//2 0 1 3

    cout << "Following is DFS (starting from vertex 2) \n";
    g.DFS(2);//2 0 1 3
    return 0;
}

拓扑排序

• 一个有向图是无环的当且仅当对其进行的DFS不产生后向边。
• 拓扑排序算法生成的是有向无环图的拓扑排序。

void Graph::topologicalSortUtil(int v, vector<bool> &visited, stack<int> &Stack){
    visited[v] = true;
    list<int>::iterator i;
    for (i = adj[v].begin(); i != adj[v].end(); ++i)
        if (!visited[*i])
            topologicalSortUtil(*i, visited, Stack); 
    // Push current vertex to stack which stores result
    Stack.push(v);
} 
void Graph::topologicalSort(){
    stack<int> Stack;
    vector<bool> visited(V,false);
    for (int i = 0; i < V; i++)
      if (!visited[i])
        topologicalSortUtil(i, visited, Stack);
    //输出
    while (!Stack.empty()){
        cout << Stack.top() << " ";
        Stack.pop();
    }
}

有向图的强连通分量