圖的廣度優先和深度優先遍歷（BFS和DFS）

圖是一種靈活的數據結構，通常做爲一種模型用來定義對象之間的關係或聯繫。對象由頂點（V）表示，而對象之間的關係或者關聯則經過圖的邊（E）來表示。 圖能夠分爲有向圖和無向圖，通常用G=(V,E)來表示圖。常常用鄰接矩陣或者鄰接表來描述一副圖。 在圖的基本算法中，最初須要接觸的就是圖的遍歷算法，根據訪問節點的順序，可分爲廣度優先搜索（BFS）和深度優先搜索（DFS）。

---

廣度優先搜索（BFS） 廣度優先搜索在進一步遍歷圖中頂點以前，先訪問當前頂點的全部鄰接結點。 a .首先選擇一個頂點做爲起始結點，並將其染成灰色，其他結點爲白色。 b. 將起始結點放入隊列中。 c. 從隊列首部選出一個頂點，並找出全部與之鄰接的結點，將找到的鄰接結點放入隊列尾部，將已訪問過結點塗成黑色，沒訪問過的結點是白色。若是頂點的顏色是灰色，表示已經發現而且放入了隊列，若是頂點的顏色是白色，表示尚未發現 d. 按照一樣的方法處理隊列中的下一個結點。 基本就是出隊的頂點變成黑色，在隊列裏的是灰色，還沒入隊的是白色。 用一副圖來表達這個流程以下：

從頂點1開始進行廣度優先搜索：

1. 初始狀態，從頂點1開始，隊列={1}
2. 訪問1的鄰接頂點，1出隊變黑，2,3入隊，隊列={2,3,}
3. 訪問2的鄰接結點，2出隊，4入隊，隊列={3,4}
4. 訪問3的鄰接結點，3出隊，隊列={4}
5. 訪問4的鄰接結點，4出隊，隊列={ 空} 結點5對於1來講不可達。 上面的圖能夠經過以下鄰接矩陣表示：

int maze[5][5] = {
	{ 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0 },
	{ 0, 1, 1, 1, 0 },
	{ 1, 0, 0, 0, 0 },
	{ 0, 0, 1, 1, 0 }
};

複製代碼

BFS核心代碼以下：

#include <iostream>
#include <queue>
#define N 5
using namespace std;
int maze[N][N] = {
	{ 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 1, 0 },
	{ 0, 1, 1, 1, 0 },
	{ 1, 0, 0, 0, 0 },
	{ 0, 0, 1, 1, 0 }
};
int visited[N + 1] = { 0, };
void BFS(int start)
{
	queue<int> Q;
	Q.push(start);
	visited[start] = 1;
	while (!Q.empty())
	{
		int front = Q.front();
		cout << front << " ";
		Q.pop();
		for (int i = 1; i <= N; i++)
		{
			if (!visited[i] && maze[front - 1][i - 1] == 1)
			{
				visited[i] = 1;
				Q.push(i);
			}
		}
	}
}
int main()
{
	for (int i = 1; i <= N; i++)
	{
		if (visited[i] == 1)
			continue;
		BFS(i);
	}
	return 0;
}
複製代碼

---

深度優先搜索（DFS） 深度優先搜索在搜索過程當中訪問某個頂點後，須要遞歸地訪問此頂點的全部未訪問過的相鄰頂點。 初始條件下全部節點爲白色，選擇一個做爲起始頂點，按照以下步驟遍歷： a. 選擇起始頂點塗成灰色，表示還未訪問 b. 從該頂點的鄰接頂點中選擇一個，繼續這個過程（即再尋找鄰接結點的鄰接結點），一直深刻下去，直到一個頂點沒有鄰接結點了，塗黑它，表示訪問過了 c. 回溯到這個塗黑頂點的上一層頂點，再找這個上一層頂點的其他鄰接結點，繼續如上操做，若是全部鄰接結點往下都訪問過了，就把本身塗黑，再回溯到更上一層。 d. 上一層繼續作如上操做，知道全部頂點都訪問過。 用圖能夠更清楚的表達這個過程：

從頂點1開始作深度搜索：

1. 初始狀態，從頂點1開始
2. 依次訪問過頂點1,2,3後，終止於頂點3
3. 從頂點3回溯到頂點2，繼續訪問頂點5，而且終止於頂點5
4. 從頂點5回溯到頂點2，而且終止於頂點2
5. 從頂點2回溯到頂點1，並終止於頂點1
6. 從頂點4開始訪問，並終止於頂點4

上面的圖能夠經過以下鄰接矩陣表示：

int maze[5][5] = {
	{ 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 0, 1 },
	{ 0, 0, 1, 0, 0 },
	{ 1, 1, 0, 0, 1 },
	{ 0, 0, 1, 0, 0 }
};
複製代碼

DFS核心代碼以下（遞歸實現）：

#include <iostream>
#define N 5
using namespace std;
int maze[N][N] = {
	{ 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 0, 1 },
	{ 0, 0, 1, 0, 0 },
	{ 1, 1, 0, 0, 1 },
	{ 0, 0, 1, 0, 0 }
};
int visited[N + 1] = { 0, };
void DFS(int start)
{
	visited[start] = 1;
	for (int i = 1; i <= N; i++)
	{
		if (!visited[i] && maze[start - 1][i - 1] == 1)
			DFS(i);
	}
	cout << start << " ";
}
int main()
{
	for (int i = 1; i <= N; i++)
	{
		if (visited[i] == 1)
			continue;
		DFS(i);
	}
	return 0;
}
複製代碼

非遞歸實現以下，藉助一個棧：

#include <iostream>
#include <stack>
#define N 5
using namespace std;
int maze[N][N] = {
	{ 0, 1, 1, 0, 0 },
	{ 0, 0, 1, 0, 1 },
	{ 0, 0, 1, 0, 0 },
	{ 1, 1, 0, 0, 1 },
	{ 0, 0, 1, 0, 0 }
};
int visited[N + 1] = { 0, };
void DFS(int start)
{
	stack<int> s;
	s.push(start);
	visited[start] = 1;
	bool is_push = false;
	while (!s.empty())
	{
		is_push = false;
		int v = s.top();
		for (int i = 1; i <= N; i++)
		{
			if (maze[v - 1][i - 1] == 1 && !visited[i])
			{
				visited[i] = 1;
				s.push(i);
				is_push = true;
				break;
			}
		}
		if (!is_push)
		{
			cout << v << " ";
			s.pop();
		}

	}
}
int main()
{
	for (int i = 1; i <= N; i++)
	{
		if (visited[i] == 1)
			continue;
		DFS(i);
	}
	return 0;
}
複製代碼

有的DFS是先訪問讀取到的結點，等回溯時就再也不輸出該結點，也是能夠的。算法和我上面的區別就是輸出點的時機不一樣，思想仍是同樣的。DFS在環監測和拓撲排序中都有不錯的應用。

PS: 圖文均爲本人原創，畫了好幾個小時，轉載註明出處，尊重知識勞動，謝謝~