算法與數據結構之圖的表示與遍歷
主要介紹圖論的基礎、圖的兩種表示、圖的遍歷（深度和廣度）、一個點到另外一點的路徑和最短路徑等。ios
原文訪問個人技術博客番茄技術小棧-圖論算法
圖論基礎
圖論並非研究圖畫。而是研究由節點和邊所構成的數學模型數組
圖論抽象模型
-
萬事開頭難，雖然看上去很複雜，可是慢慢學習深刻以後會體會到他的魅力bash
-
不少信息之間的聯繫均可以使用圖來表示。數據可視化微信
圖能夠表示的關係
- 交通運輸（每一個節點是城市，邊是道路。點是航站樓，邊是航線）
- 社交網絡（人 & 好友關係 電影 & 電影類似程度）
- 互聯網（域名 域名跳轉）
- 工做安排（前後程度）
- 腦區活動
- 程序狀態執行（自動機）
圖的分類：
- 無向圖（Undirected Graph）人和人認識就是邊，沒有方向
- 有向圖（Directed Graph）自動機轉移有方向
-
無向圖是一種特殊的有向圖網絡
-
無權圖（邊:認識不認識：好友度）數據結構
-
有權圖（邊帶值：電影類似程度 & 路長）函數
圖的連通性：
三圖或者一圖
- 能夠看作是三張圖。也能夠視爲一個。
- 圖不是徹底連通的。
簡單圖（simple Graph）：
- 考慮最小生成樹，連通性，這兩種邊意義不大
- 簡單圖：不包含。
圖的表示
- 對於邊的表示採用什麼樣的數據結構：
鄰接矩陣
n個節點 就是一個n行n列的矩陣，無向圖對角線對稱：1表示連通。0表示沒通學習
有向圖的矩陣表示：測試
鄰接表：
對於每一個頂點只表達與這個頂點相鏈接的信息
- 每一行都是一個鏈表，存放了對這一行而言相連的節點。
- 也能夠表示有向圖
優勢：存儲空間小
具體問題具體分析
-
鄰接表適合表示稀疏圖 (Sparse Graph) 多少
-
鄰接矩陣適合表示稠密圖 (Dense Graph)邊多
- 每一個電影和其餘全部電影之間的類似度。無論類似大小都是鏈接的邊。全部的點之間都有邊。
-
稠密：邊的個數與能擁有的最大邊的個數對比。
-
以下圖就是一個稀疏圖：
- 稠密圖徹底圖
代碼實現
鄰接矩陣代碼實現
// 稠密圖 - 鄰接矩陣
class DenseGraph{
private:
int n, m; // 節點數和邊數
bool directed; // 是否爲有向圖
vector<vector<bool>> g; // 圖的具體數據
public:
// 構造函數
DenseGraph( int n , bool directed ){
assert( n >= 0 );
this->n = n;
this->m = 0; // 初始化沒有任何邊
this->directed = directed;
// g初始化爲n*n的布爾矩陣, 每個g[i][j]均爲false, 表示沒有任和邊
//g = vector<vector<bool>>(n, vector<bool>(n, false));
for (int i = 0; i < n; ++i) {
g.push_back(vector<bool>(n, false));
}
}
~DenseGraph(){ }
int V(){ return n;} // 返回節點個數
int E(){ return m;} // 返回邊的個數
// 向圖中添加一個邊，v和w表示一個頂點
void addEdge( int v , int w ){
assert( v >= 0 && v < n );
assert( w >= 0 && w < n );
if( hasEdge( v , w ) )
return;
g[v][w] = true;
if( !directed )
g[w][v] = true;
m ++;
}
// 驗證圖中是否有從v到w的邊
bool hasEdge( int v , int w ){
assert( v >= 0 && v < n );
assert( w >= 0 && w < n );
return g[v][w];
}
};
複製代碼
注意：
- addedge的時候已經去除了平行邊的概念。由於若是有邊之間return
- O(1)來判斷是否有邊
稀疏圖代碼實現
// 稀疏圖 - 鄰接表
class SparseGraph{
private:
int n, m; // 節點數和邊數
bool directed; // 是否爲有向圖
vector<vector<int>> g; // 圖的具體數據
public:
// 構造函數
SparseGraph( int n , bool directed ){
assert( n >= 0 );
this->n = n;
this->m = 0; // 初始化沒有任何邊
this->directed = directed;
// g初始化爲n個空的vector, 表示每個g[i]都爲空, 即沒有任和邊
//g = vector<vector<int>>(n, vector<int>());
for (int i = 0; i < n; ++i) {
g.push_back(vector<int>());
}
}
~SparseGraph(){ }
int V(){ return n;} // 返回節點個數
int E(){ return m;} // 返回邊的個數
// 向圖中添加一個邊
void addEdge( int v, int w ){
assert( v >= 0 && v < n );
assert( w >= 0 && w < n );
g[v].push_back(w);
//處理自環邊
if( v != w && !directed )
g[w].push_back(v);
m ++;
}
// 驗證圖中是否有從v到w的邊
bool hasEdge( int v , int w ){
assert( v >= 0 && v < n );
assert( w >= 0 && w < n );
//使用鄰接表在判斷解決平行邊複雜度高
for( int i = 0 ; i < g[v].size() ; i ++ )
if( g[v][i] == w )
return true;
return false;
}
};
複製代碼
鄰接表取消平行邊複雜度度過大。
鄰接表的優點
- 遍歷鄰邊 - 圖算法中最多見的操做
- 遍歷鄰邊，鄰接表有優點
相鄰點迭代器
稀疏圖的迭代器代碼實現
// 鄰邊迭代器, 傳入一個圖和一個頂點,
// 迭代在這個圖中和這個頂點向連的全部頂點
class adjIterator{
private:
SparseGraph &G; // 圖G的引用
int v;
int index;
public:
// 構造函數
adjIterator(SparseGraph &graph, int v): G(graph){
this->v = v;
this->index = 0;
}
~adjIterator(){}
// 返回圖G中與頂點v相鏈接的第一個頂點
int begin(){
index = 0;
if( G.g[v].size() )
return G.g[v][index];
// 若沒有頂點和v相鏈接, 則返回-1
return -1;
}
// 返回圖G中與頂點v相鏈接的下一個頂點
int next(){
index ++;
if( index < G.g[v].size() )
return G.g[v][index];
// 若沒有頂點和v相鏈接, 則返回-1
return -1;
}
// 查看是否已經迭代完了圖G中與頂點v相鏈接的全部頂點
bool end(){
return index >= G.g[v].size();
}
};
複製代碼
稠密圖的代碼實現
// 鄰邊迭代器, 傳入一個圖和一個頂點,
// 迭代在這個圖中和這個頂點向連的全部頂點
class adjIterator{
private:
DenseGraph &G; // 圖G的引用
int v;
int index;
public:
// 構造函數
adjIterator(DenseGraph &graph, int v): G(graph){
assert( v >= 0 && v < G.n );
this->v = v;
this->index = -1; // 索引從-1開始, 由於每次遍歷都須要調用一次next()
}
~adjIterator(){}
// 返回圖G中與頂點v相鏈接的第一個頂點
int begin(){
// 索引從-1開始, 由於每次遍歷都須要調用一次next()
index = -1;
return next();
}
// 返回圖G中與頂點v相鏈接的下一個頂點
int next(){
// 從當前index開始向後搜索, 直到找到一個g[v][index]爲true
for( index += 1 ; index < G.V() ; index ++ )
if( G.g[v][index] )
return index;
// 若沒有頂點和v相鏈接, 則返回-1
return -1;
}
// 查看是否已經迭代完了圖G中與頂點v相鏈接的全部頂點
bool end(){
return index >= G.V();
}
};
複製代碼
測試
#include <iostream>
#include "SparseGraph.h"
#include "DenseGraph.h"
using namespace std;
int main() {
int N = 20;
int M = 100;
srand( time(NULL) );
// Sparse Graph
SparseGraph g1(N , false);
for( int i = 0 ; i < M ; i ++ ){
int a = rand()%N;
int b = rand()%N;
g1.addEdge( a , b );
}
// O(E)
for( int v = 0 ; v < N ; v ++ ){
cout<<v<<" : ";
SparseGraph::adjIterator adj( g1 , v );
for( int w = adj.begin() ; !adj.end() ; w = adj.next() )
cout<<w<<" ";
cout<<endl;
}
cout<<endl;
// Dense Graph
DenseGraph g2(N , false);
for( int i = 0 ; i < M ; i ++ ){
int a = rand()%N;
int b = rand()%N;
g2.addEdge( a , b );
}
// O(V^2)
for( int v = 0 ; v < N ; v ++ ){
cout<<v<<" : ";
DenseGraph::adjIterator adj( g2 , v );
for( int w = adj.begin() ; !adj.end() ; w = adj.next() )
cout<<w<<" ";
cout<<endl;
}
return 0;
}
複製代碼
運行結果：
0 : 0 7 17 18 4 2 17 17 7 9 8
1 : 15 12 19 8 5 11 3 4 16 4
2 : 19 6 2 17 3 9 6 19 4 6 17 7 6 0
3 : 2 4 19 16 8 10 19 11 1 7 5 16 17
4 : 10 15 3 2 14 0 17 1 16 1
5 : 11 14 7 1 14 15 6 3 15
6 : 8 2 16 8 11 19 10 2 6 2 11 14 5 9 2 12 17
7 : 9 9 17 19 5 0 14 2 3 0 10
8 : 9 6 6 9 14 14 1 16 3 17 0
9 : 7 15 8 19 7 8 12 2 13 6 0
10 : 4 10 6 3 19 18 7
11 : 6 5 6 1 3
12 : 1 9 6
13 : 16 9 18
14 : 18 5 8 8 4 7 16 5 6 17
15 : 9 1 15 4 5 15 18 5
16 : 6 13 8 3 14 4 3 18 1
17 : 19 7 2 0 2 4 8 0 0 14 3 6
18 : 14 13 0 15 10 16 19 18
19 : 2 17 9 1 6 7 3 2 10 3 18
0 : 2 3 7 8 13 14 19
1 : 5 10 12 16 19
2 : 0 3 5 6 7 9 10 11 12 18
3 : 0 2 6 8 10 14 15 17 18 19
4 : 4 6 7 8 14 17 18 19
5 : 1 2 7 10 14 15 17 19
6 : 2 3 4 8 9 11 12 14
7 : 0 2 4 5 7 8 9 13 15 16 19
8 : 0 3 4 6 7 17 18 19
9 : 2 6 7 15 16
10 : 1 2 3 5 13 18
11 : 2 6 11 13 15 16 18 19
12 : 1 2 6
13 : 0 7 10 11 15 17 19
14 : 0 3 4 5 6
15 : 3 5 7 9 11 13 16
16 : 1 7 9 11 15 16 17
17 : 3 4 5 8 13 16 17
18 : 2 3 4 8 10 11 19
19 : 0 1 3 4 5 7 8 11 13 18
複製代碼
生成稠密圖和稀疏圖類封裝
template <typename Graph>
class ReadGraph{
public:
// 從文件filename中讀取圖的信息, 存儲進圖graph中
ReadGraph(Graph &graph, const string &filename){
ifstream file(filename);
string line;
int V, E;
assert( file.is_open() );
// 第一行讀取圖中的節點個數和邊的個數
assert( getline(file, line) );
stringstream ss(line);
ss>>V>>E;
assert( V == graph.V() );
// 讀取每一條邊的信息
for( int i = 0 ; i < E ; i ++ ){
assert( getline(file, line) );
stringstream ss(line);
int a,b;
ss>>a>>b;
assert( a >= 0 && a < V );
assert( b >= 0 && b < V );
graph.addEdge( a , b );
}
}
};
複製代碼
深度優先遍歷和聯通份量
- 深度優先遍歷
- 廣度優先遍歷
思想：一個點往下試，記錄是否遍歷過（由於存在環）。
0-1-2-5-3-4-6
圖示爲3個聯通份量
深度優先遍歷代碼實現
遍歷完成後看沒遍歷過的點
// 求無權圖的聯通份量
template <typename Graph>
class Component{
private:
Graph &G; // 圖的引用
bool *visited; // 記錄dfs的過程當中節點是否被訪問
int ccount; // 記錄聯通份量個數
int *id; // 每一個節點所對應的聯通份量標記
// 圖的深度優先遍歷(遞歸方式)
void dfs( int v ){
visited[v] = true;
id[v] = ccount;
typename Graph::adjIterator adj(G, v);
for( int i = adj.begin() ; !adj.end() ; i = adj.next() ){
if( !visited[i] )
dfs(i);
}
}
public:
// 構造函數, 求出無權圖的聯通份量
Component(Graph &graph): G(graph){
// 算法初始化
visited = new bool[G.V()];
id = new int[G.V()];
ccount = 0;
for( int i = 0 ; i < G.V() ; i ++ ){
visited[i] = false;
id[i] = -1;
}
// 求圖的聯通份量
for( int i = 0 ; i < G.V() ; i ++ )
if( !visited[i] ){
dfs(i);
ccount ++;
}
}
// 析構函數
~Component(){
delete[] visited;
delete[] id;
}
// 返回圖的聯通份量個數
int count(){
return ccount;
}
// 查詢點v和點w是否聯通
bool isConnected( int v , int w ){
assert( v >= 0 && v < G.V() );
assert( w >= 0 && w < G.V() );
return id[v] == id[w];
}
};
複製代碼
main.cpp
// 測試圖的聯通份量算法
int main() {
// TestG1.txt
string filename1 = "testG1.txt";
SparseGraph g1 = SparseGraph(13, false);
ReadGraph<SparseGraph> readGraph1(g1, filename1);
Component<SparseGraph> component1(g1);
cout<<"TestG1.txt, Component Count: "<<component1.count()<<endl;
cout<<endl;
// TestG2.txt
string filename2 = "testG2.txt";
SparseGraph g2 = SparseGraph(7, false);
ReadGraph<SparseGraph> readGraph2(g2, filename2);
Component<SparseGraph> component2(g2);
cout<<"TestG2.txt, Component Count: "<<component2.count()<<endl;
return 0;
}
複製代碼
結果
TestG1.txt, Component Count: 3
TestG2.txt, Component Count: 1
複製代碼
** 注意**
- 求出連通份量，能夠求出兩個結點是否相連
- 添加id來記錄。
int *id; // 每一個節點所對應的聯通份量標記
複製代碼
- 並查集只能讓咱們知道兩個結點是否相連。而路徑須要圖論來解決
尋路
深度優先得到一條路徑。遍歷的同時保存是從哪遍歷過來的。
int * from; // 記錄路徑, from[i]表示查找的路徑上i的上一個節點
// 路徑查詢
template <typename Graph>
class Path{
private:
Graph &G; // 圖的引用
int s; // 起始點
bool* visited; // 記錄dfs的過程當中節點是否被訪問
int * from; // 記錄路徑, from[i]表示查找的路徑上i的上一個節點
// 圖的深度優先遍歷
void dfs( int v ){
visited[v] = true;
typename Graph::adjIterator adj(G, v);
for( int i = adj.begin() ; !adj.end() ; i = adj.next() ){
if( !visited[i] ){
from[i] = v;
dfs(i);
}
}
}
public:
// 構造函數, 尋路算法, 尋找圖graph從s點到其餘點的路徑
Path(Graph &graph, int s):G(graph){
// 算法初始化
assert( s >= 0 && s < G.V() );
visited = new bool[G.V()];
from = new int[G.V()];
for( int i = 0 ; i < G.V() ; i ++ ){
visited[i] = false;
from[i] = -1;
}
this->s = s;
// 尋路算法
dfs(s);
}
// 析構函數
~Path(){
delete [] visited;
delete [] from;
}
// 查詢從s點到w點是否有路徑
bool hasPath(int w){
assert( w >= 0 && w < G.V() );
return visited[w];
}
// 查詢從s點到w點的路徑, 存放在vec中
void path(int w, vector<int> &vec){
assert( hasPath(w) );
stack<int> s;
// 經過from數組逆向查找到從s到w的路徑, 存放到棧中
int p = w;
while( p != -1 ){
s.push(p);
p = from[p];
}
// 從棧中依次取出元素, 得到順序的從s到w的路徑
vec.clear();
while( !s.empty() ){
vec.push_back( s.top() );
s.pop();
}
}
// 打印出從s點到w點的路徑
void showPath(int w){
assert( hasPath(w) );
vector<int> vec;
path( w , vec );
for( int i = 0 ; i < vec.size() ; i ++ ){
cout<<vec[i];
if( i == vec.size() - 1 )
cout<<endl;
else
cout<<" -> ";
}
}
};
複製代碼
main.cpp:
// 測試尋路算法
int main() {
string filename = "testG.txt";
SparseGraph g = SparseGraph(7, false);
ReadGraph<SparseGraph> readGraph(g, filename);
g.show();
cout<<endl;
Path<SparseGraph> path(g,0);
cout<<"Path from 0 to 6 : " << endl;
path.showPath(6);
return 0;
}
複製代碼
運行結果：
vertex 0: 1 2 5 6
vertex 1: 0
vertex 2: 0
vertex 3: 4 5
vertex 4: 3 5 6
vertex 5: 0 3 4
vertex 6: 0 4
DFS : 0 -> 5 -> 3 -> 4 -> 6
[Finished in 1.2s]
複製代碼
複雜度：
- 稀疏圖（鄰接表）： O( V + E ), 想得到一個節點的全部相鄰節點的時候，咱們要將圖中全部節點掃一遍
- 稠密圖（鄰接矩陣）：O( V^2 )
注意:
- 深度優先遍歷算法對有向圖依然有效
- 深度優先遍歷也能夠用於判斷圖中是否有環。
圖的廣度優先遍歷
通常須要使用隊列使用隊列。
- 隊列爲空表示遍歷完成
- 距離0節點的距離排序，先遍歷的節點距離<=後遍歷的節點距離
- 記錄距離而且用from數組記錄來源節點能夠求出最短路徑。
- 廣度優先遍歷：求出了無權圖的最短路徑。
代碼實現：
// 尋找無權圖的最短路徑
template <typename Graph>
class ShortestPath{
private:
Graph &G; // 圖的引用
int s; // 起始點
bool *visited; // 記錄dfs的過程當中節點是否被訪問
int *from; // 記錄路徑, from[i]表示查找的路徑上i的上一個節點
int *ord; // 記錄路徑中節點的次序。ord[i]表示i節點在路徑中的次序；記錄最短路徑
public:
// 構造函數, 尋找無權圖graph從s點到其餘點的最短路徑
ShortestPath(Graph &graph, int s):G(graph){
// 算法初始化
assert( s >= 0 && s < graph.V() );
visited = new bool[graph.V()];
from = new int[graph.V()];
ord = new int[graph.V()];
for( int i = 0 ; i < graph.V() ; i ++ ){
visited[i] = false;
from[i] = -1;
ord[i] = -1;
}
this->s = s;
// 無向圖最短路徑算法, 從s開始廣度優先遍歷整張圖
queue<int> q;
q.push( s );
visited[s] = true;
ord[s] = 0;
while( !q.empty() ){
int v = q.front();
q.pop();
typename Graph::adjIterator adj(G, v);
for( int i = adj.begin() ; !adj.end() ; i = adj.next() )
if( !visited[i] ){
q.push(i);
visited[i] = true;
from[i] = v;
ord[i] = ord[v] + 1;
}
}
}
// 析構函數
~ShortestPath(){
delete [] visited;
delete [] from;
delete [] ord;
}
// 查詢從s點到w點是否有路徑
bool hasPath(int w){
assert( w >= 0 && w < G.V() );
return visited[w];
}
// 查詢從s點到w點的路徑, 存放在vec中
void path(int w, vector<int> &vec){
assert( w >= 0 && w < G.V() );
stack<int> s;
// 經過from數組逆向查找到從s到w的路徑, 存放到棧中
int p = w;
while( p != -1 ){
s.push(p);
p = from[p];
}
// 從棧中依次取出元素, 得到順序的從s到w的路徑
vec.clear();
while( !s.empty() ){
vec.push_back( s.top() );
s.pop();
}
}
// 打印出從s點到w點的路徑
void showPath(int w){
assert( w >= 0 && w < G.V() );
vector<int> vec;
path(w, vec);
for( int i = 0 ; i < vec.size() ; i ++ ){
cout<<vec[i];
if( i == vec.size()-1 )
cout<<endl;
else
cout<<" -> ";
}
}
// 查看從s點到w點的最短路徑長度
int length(int w){
assert( w >= 0 && w < G.V() );
return ord[w];
}
};
複製代碼
main.cpp:
// 測試無權圖最短路徑算法
int main() {
string filename = "testG.txt";
SparseGraph g = SparseGraph(7, false);
ReadGraph<SparseGraph> readGraph(g, filename);
g.show();
cout<<endl;
// 比較使用深度優先遍歷和廣度優先遍歷得到路徑的不一樣
// 廣度優先遍歷得到的是無權圖的最短路徑
Path<SparseGraph> dfs(g,0);
cout<<"DFS : ";
dfs.showPath(6);
ShortestPath<SparseGraph> bfs(g,0);
cout<<"BFS : ";
bfs.showPath(6);
return 0;
}
複製代碼
運行結果：
vertex 0: 1 2 5 6
vertex 1: 0
vertex 2: 0
vertex 3: 4 5
vertex 4: 3 5 6
vertex 5: 0 3 4
vertex 6: 0 4
DFS : 0 -> 5 -> 3 -> 4 -> 6
BFS : 0 -> 6
複製代碼
注意：
- 廣度優先必定能夠找到最短無權路徑
- 廣度優先必定能夠找到最短無權路徑並可能找到多條，深度也有可能找到。
- 多條最短路徑。跟遍歷順序有關。
-------------------------華麗的分割線--------------------
看完的朋友能夠點個喜歡/關注，您的支持是對我最大的鼓勵。
想了解更多，歡迎關注個人微信公衆號：番茄技術小棧
相關文章
- 1. 數據結構——圖的表示與遍歷
- 2. 數據結構與算法學習筆記-圖的遍歷
- 3. 數據結構與算法18-圖的遍歷
- 4. 數據結構與算法專題之圖——圖的遍歷（深度優先遍歷和廣度優先遍歷）
- 5. 數據結構與算法之由遍歷構造二叉樹
- 6. 數據結構與算法之二叉樹的遍歷方式
- 7. 數據結構與算法之02樹的遍歷
- 8. 數據結構與算法Java版——圖及其遍歷
- 9. 前端算法之與數據結構-廣度遍歷和深度遍歷與二叉樹遍歷
- 10. 【算法與數據結構】圖 -- 數組表示法
- 更多相關文章...
- • XML DOM 遍歷節點樹 - XML DOM 教程
- • Scala 方法與函數 - Scala教程
- • C# 中 foreach 遍歷的用法
- • 算法總結-回溯法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解決方法
- 2. Qt5.7以上調用虛擬鍵盤(支持中文)，以及源碼修改(可拖動，水平縮放)
- 3. 軟件測試面試- 購物車功能測試用例設計
- 4. ElasticSearch（概念篇）：你知道的, 爲了搜索…
- 5. redux理解
- 6. gitee創建第一個項目
- 7. 支持向量機之硬間隔（一步步推導，通俗易懂）
- 8. Mysql 異步複製延遲的原因及解決方案
- 9. 如何在運行SEPM配置嚮導時將不可認的複雜數據庫密碼改爲簡單密碼
- 10. windows系統下tftp服務器使用
歡迎關注本站公眾號,獲取更多信息
