圖是一種靈活的數據結構，一般作為一種模型用來定義對象之間的關系或聯系。對象由頂點（V）表示，而對象之間的關系或者關聯則通過圖的邊（E）來表示。 圖可以分為有向圖和無向圖，一般用G=(V,E)來表示圖。經常用鄰接矩陣或者鄰接表來描述一副圖。 在圖的基本算法中，最初需要接觸的就是圖的遍歷算法，根據訪問節點的順序，可分為廣度優先搜索（BFS）和深度優先搜索（DFS）。
廣度優先搜索（BFS） 廣度優先搜索在進一步遍歷圖中頂點之前，先訪問當前頂點的所有鄰接結點。 a .首先選擇一個頂點作為起始結點，並將其染成灰色，其余結點為白色。 b. 將起始結點放入隊列中。 c. 從隊列首部選出一個頂點，並找出所有與之鄰接的結點，將找到的鄰接結點放入隊列尾部，將已訪問過結點塗成黑色，沒訪問過的結點是白色。如果頂點的顏色是灰色，表示已經發現並且放入了隊列，如果頂點的顏色是白色，表示還沒有發現 d. 按照同樣的方法處理隊列中的下一個結點。 基本就是出隊的頂點變成黑色，在隊列里的是灰色，還沒入隊的是白色。 用一副圖來表達這個流程如下：
從頂點1開始進行廣度優先搜索：
- 初始狀態，從頂點1開始，隊列={1}
- 訪問1的鄰接頂點，1出隊變黑，2,3入隊，隊列={2,3,}
- 訪問2的鄰接結點，2出隊，4入隊，隊列={3,4}
- 訪問3的鄰接結點，3出隊，隊列={4}
- 訪問4的鄰接結點，4出隊，隊列={ 空} 結點5對於1來說不可達。 上面的圖可以通過如下鄰接矩陣表示：
1 int maze[5][5] = { 2 { 0, 1, 1, 0, 0 }, 3 { 0, 0, 1, 1, 0 }, 4 { 0, 1, 1, 1, 0 }, 5 { 1, 0, 0, 0, 0 }, 6 { 0, 0, 1, 1, 0 } 7 };
BFS核心代碼如下：
1 #include <iostream> 2 #include <queue> 3 #define N 5 4 using namespace std; 5 int maze[N][N] = { 6 { 0, 1, 1, 0, 0 }, 7 { 0, 0, 1, 1, 0 }, 8 { 0, 1, 1, 1, 0 }, 9 { 1, 0, 0, 0, 0 }, 10 { 0, 0, 1, 1, 0 } 11 }; 12 int visited[N + 1] = { 0, }; 13 void BFS(int start) 14 { 15 queue<int> Q; 16 Q.push(start); 17 visited[start] = 1; 18 while (!Q.empty()) 19 { 20 int front = Q.front(); 21 cout << front << " "; 22 Q.pop(); 23 for (int i = 1; i <= N; i++) 24 { 25 if (!visited[i] && maze[front - 1][i - 1] == 1) 26 { 27 visited[i] = 1; 28 Q.push(i); 29 } 30 } 31 } 32 } 33 int main() 34 { 35 for (int i = 1; i <= N; i++) 36 { 37 if (visited[i] == 1) 38 continue; 39 BFS(i); 40 } 41 return 0; 42 }
深度優先搜索（DFS） 深度優先搜索在搜索過程中訪問某個頂點后，需要遞歸地訪問此頂點的所有未訪問過的相鄰頂點。 初始條件下所有節點為白色，選擇一個作為起始頂點，按照如下步驟遍歷： a. 選擇起始頂點塗成灰色，表示還未訪問 b. 從該頂點的鄰接頂點中選擇一個，繼續這個過程（即再尋找鄰接結點的鄰接結點），一直深入下去，直到一個頂點沒有鄰接結點了，塗黑它，表示訪問過了 c. 回溯到這個塗黑頂點的上一層頂點，再找這個上一層頂點的其余鄰接結點，繼續如上操作，如果所有鄰接結點往下都訪問過了，就把自己塗黑，再回溯到更上一層。 d. 上一層繼續做如上操作，知道所有頂點都訪問過。 用圖可以更清楚的表達這個過程：
從頂點1開始做深度搜索：
- 初始狀態，從頂點1開始
- 依次訪問過頂點1,2,3后，終止於頂點3
- 從頂點3回溯到頂點2，繼續訪問頂點5，並且終止於頂點5
- 從頂點5回溯到頂點2，並且終止於頂點2
- 從頂點2回溯到頂點1，並終止於頂點1
-
從頂點4開始訪問，並終止於頂點4
上面的圖可以通過如下鄰接矩陣表示：
1 int maze[5][5] = { 2 { 0, 1, 1, 0, 0 }, 3 { 0, 0, 1, 0, 1 }, 4 { 0, 0, 1, 0, 0 }, 5 { 1, 1, 0, 0, 1 }, 6 { 0, 0, 1, 0, 0 } 7 };
DFS核心代碼如下（遞歸實現）：
1 #include <iostream> 2 #define N 5 3 using namespace std; 4 int maze[N][N] = { 5 { 0, 1, 1, 0, 0 }, 6 { 0, 0, 1, 0, 1 }, 7 { 0, 0, 1, 0, 0 }, 8 { 1, 1, 0, 0, 1 }, 9 { 0, 0, 1, 0, 0 } 10 }; 11 int visited[N + 1] = { 0, }; 12 void DFS(int start) 13 { 14 visited[start] = 1; 15 for (int i = 1; i <= N; i++) 16 { 17 if (!visited[i] && maze[start - 1][i - 1] == 1) 18 DFS(i); 19 } 20 cout << start << " "; 21 } 22 int main() 23 { 24 for (int i = 1; i <= N; i++) 25 { 26 if (visited[i] == 1) 27 continue; 28 DFS(i); 29 } 30 return 0; 31 }
非遞歸實現如下，借助一個棧：
1 #include <iostream> 2 #include <stack> 3 #define N 5 4 using namespace std; 5 int maze[N][N] = { 6 { 0, 1, 1, 0, 0 }, 7 { 0, 0, 1, 0, 1 }, 8 { 0, 0, 1, 0, 0 }, 9 { 1, 1, 0, 0, 1 }, 10 { 0, 0, 1, 0, 0 } 11 }; 12 int visited[N + 1] = { 0, }; 13 void DFS(int start) 14 { 15 stack<int> s; 16 s.push(start); 17 visited[start] = 1; 18 bool is_push = false; 19 while (!s.empty()) 20 { 21 is_push = false; 22 int v = s.top(); 23 for (int i = 1; i <= N; i++) 24 { 25 if (maze[v - 1][i - 1] == 1 && !visited[i]) 26 { 27 visited[i] = 1; 28 s.push(i); 29 is_push = true; 30 break; 31 } 32 } 33 if (!is_push) 34 { 35 cout << v << " "; 36 s.pop(); 37 } 38 39 } 40 } 41 int main() 42 { 43 for (int i = 1; i <= N; i++) 44 { 45 if (visited[i] == 1) 46 continue; 47 DFS(i); 48 } 49 return 0; 50 }
有的DFS是先訪問讀取到的結點，等回溯時就不再輸出該結點，也是可以的。算法和我上面的區別就是輸出點的時機不同，思想還是一樣的。DFS在環監測和拓撲排序中都有不錯的應用。