圖的鄰接矩陣表示

通常圖的表示有兩種方法：鄰接矩陣，鄰接表。

本文用鄰接矩陣實現，一是程式碼量更少，二是程式碼風格也更貼近C語言。但不論是圖的哪種實現方式，其基本的實現思想是不變的。

1：節點的資訊，我們用一維陣列a[n]來儲存，假設圖共有n個節點。

2：節點與節點間的關係，我們用二維陣列b[n][n]儲存。

3：b[i][j]表示，從i到j有向連通，b[j][i]表示從j到i有向連通，而當i=j時(矩陣的對角線上的元素)，b[i][j]沒有實際意思，在遍歷時，我可以用來儲存定節點是否訪問過。

圖的深度優先遍歷

DFS類似於樹的先根遍歷，儘可能深的去訪問節點。

DFS演算法過程我們用到了遞迴的思想，如果還需要求出路徑，可以藉助棧來實現(後文會不斷的實現圖的各種演算法)。

步驟1：訪問節點，將該節點標記為已訪問。

步驟2：如果節點還有未標記的鄰接點，繼續步驟1，否則返回。

圖的廣度優先遍歷

BFS我們用佇列來實現。

步驟1：如果佇列為空，則返回，否則，取出佇列頭節點，將該節點標記為已訪問。

步驟2：同時，將該節點所有未標記的鄰接點，加入佇列尾，繼續步驟1。

圖的非遞迴遍歷

我們藉助棧來實現。

步驟1：如果棧為空，則退出程式，否則，訪問棧頂節點，但不彈出棧點節點。

步驟2：如果棧頂節點的所有直接鄰接點都已訪問過，則彈出棧頂節點，否則，將該棧頂節點的未訪問的其中一個鄰接點壓入棧，同時，標記該鄰接點為已訪問，繼續步驟1。

如下例子：

深度和廣度遍歷程式碼如下：

package com.collonn.algorithm;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * 無向圖，鄰接矩陣<br/>
 * 深度優先遍歷<br/>
 * 廣度優先遍歷<br/>
 */
public class GrfDfsBfs {
	private int total;
	private String[] nodes;
	private int[][] matirx;

	public GrfDfsBfs(int total, String[] nodes) {
		this.total = total;
		this.nodes = nodes;
		this.matirx = new int[total][total];
	}

	private void printMatrix() {
		System.out.println("----------------- matrix -----------------");
		System.out.println("---0-1-2-3-4-5-6-7-8--");
		System.out.println("---A-B-C-D-E-F-G-H-I--");
		for (int i = 0; i < this.total; i++) {
			System.out.print(" " + this.nodes[i] + "|");
			for (int j = 0; j < this.total; j++) {
				System.out.print(this.matirx[i][j] + "-");
			}
			System.out.print("\n");
		}
		System.out.println("----------------- matrix -----------------");
	}

	// 設定[i][i]位置處的元素值為0，0表示圖中的定點i未被訪問，1表示圖中的定點i已被訪問
	private void resetVisited() {
		for (int i = 0; i < this.total; i++) {
			this.matirx[i][i] = 0;
		}
	}

	// 圖的深度優先遍歷(遞迴方法)
	private void dfsRecursive(int i) {
		// 如果已訪問，則返回
		if (this.matirx[i][i] == 1) {
			return;
		}

		this.matirx[i][i] = 1;
		System.out.print(this.nodes[i]);

		for (int j = 0; j < this.total; j++) {
			// i=j時，[i][j]表示節點是否被訪問過，不參與dfs
			if (i == j) {
				continue;
			}

			if (this.matirx[i][j] == 1) {
				dfsRecursive(j);
			}
		}
	}
	
	// 圖的深度優先遍歷(用棧實現)
	private void dfsStack(Stack<Integer> stack) {
		// 如果已訪問，則返回
		int k = -1;
		
		while(!stack.empty()){
			k = stack.peek().intValue();
			boolean needPop = true;
			for(int i = 0; i < this.total; i++){
				if(this.matirx[k][i] == 1 && this.matirx[i][i] == 0){
					stack.push(i);
					this.matirx[i][i] = 1;
					System.out.print(this.nodes[i]);
					needPop = false;
					break;
				}
			}
			if(needPop){
				stack.pop();
			}
		}
	}

	// 圖的廣度優先遍歷
	private void bfsQueue(Queue<Integer> ls) {
		if (ls == null || ls.size() == 0) {
			return;
		}

		int i = ls.poll().intValue();
		// 如果已訪問，則跳過該元素，繼續訪問佇列的下一個元素
		if (this.matirx[i][i] == 1) {
			this.bfsQueue(ls);
			return;
		}

		this.matirx[i][i] = 1;
		System.out.print("" + this.nodes[i]);

		for (int j = 0; j < this.total; j++) {
			// i=j時，[i][j]表示節點是否被訪問過，不參與bfs
			if (i == j) {
				continue;
			}

			//如果頂點已訪問過,則不再加入佇列
			if (this.matirx[i][j] == 1 && this.matirx[j][j] != 1) {
				ls.offer(j);
			}
		}

		// System.out.print("\n佇列元素:");
		// for (Integer k : ls) {
		// System.out.print(k);
		// }
		// System.out.println("");

		this.bfsQueue(ls);
	}

	// 初始化圖資料
	// 0---1---2---3---4---5---6---7---8---
	// A---B---C---D---E---F---G---H---I---
	private void initGrf() {
		// A-B, A-D, A-E
		this.matirx[0][1] = 1;
		this.matirx[1][0] = 1;
		this.matirx[0][3] = 1;
		this.matirx[3][0] = 1;
		this.matirx[0][4] = 1;
		this.matirx[4][0] = 1;
		// B-C
		this.matirx[1][2] = 1;
		this.matirx[2][1] = 1;
		// C-F
		this.matirx[2][5] = 1;
		this.matirx[5][2] = 1;
		// D-E, D-G
		this.matirx[3][4] = 1;
		this.matirx[4][3] = 1;
		this.matirx[3][6] = 1;
		this.matirx[6][3] = 1;
		// E-F, E-H
		this.matirx[4][5] = 1;
		this.matirx[5][4] = 1;
		this.matirx[4][7] = 1;
		this.matirx[7][4] = 1;
		// F-H, F-I
		this.matirx[5][7] = 1;
		this.matirx[7][5] = 1;
		this.matirx[5][8] = 1;
		this.matirx[8][5] = 1;
		// G-H
		this.matirx[6][7] = 1;
		this.matirx[7][6] = 1;
		// H-I
		this.matirx[7][8] = 1;
		this.matirx[8][7] = 1;
	}

	// 初始化圖資料
	// 0---1---2---3---4---5---6---7---8---
	// A---B---C---D---E---F---G---H---I---
	private void initGrf2() {
		// A-B, A-D, A-E
		this.matirx[0][1] = 1;
		this.matirx[1][0] = 1;
		this.matirx[0][3] = 1;
		this.matirx[3][0] = 1;
		this.matirx[0][4] = 1;
		this.matirx[4][0] = 1;
		// B-C
		this.matirx[1][2] = 1;
		this.matirx[2][1] = 1;
		// C-F
		this.matirx[2][5] = 1;
		this.matirx[5][2] = 1;
		// D-E
		this.matirx[3][4] = 1;
		this.matirx[4][3] = 1;
		// E-F, E-H
		this.matirx[4][5] = 1;
		this.matirx[5][4] = 1;
		this.matirx[4][7] = 1;
		this.matirx[7][4] = 1;
		// F-H, F-I
		this.matirx[5][7] = 1;
		this.matirx[7][5] = 1;
		this.matirx[5][8] = 1;
		this.matirx[8][5] = 1;
		// G-H
		this.matirx[6][7] = 1;
		this.matirx[7][6] = 1;
		// H-I
		this.matirx[7][8] = 1;
		this.matirx[8][7] = 1;
	}

	// 初始化圖資料
	// 0---1---2---3---4---5---6---7---8---
	// A---B---C---D---E---F---G---H---I---
	private void initGrf3() {
		// A-D, A-E
		this.matirx[0][3] = 1;
		this.matirx[3][0] = 1;
		this.matirx[0][4] = 1;
		this.matirx[4][0] = 1;
		// B-C
		this.matirx[1][2] = 1;
		this.matirx[2][1] = 1;
		// C-F
		this.matirx[2][5] = 1;
		this.matirx[5][2] = 1;
		// E-H, E-I
		this.matirx[4][7] = 1;
		this.matirx[7][4] = 1;
		this.matirx[4][8] = 1;
		this.matirx[8][4] = 1;
		// F-I
		this.matirx[5][8] = 1;
		this.matirx[8][5] = 1;
		// G-H
		this.matirx[6][7] = 1;
		this.matirx[7][6] = 1;
	}

	public static void main(String[] args) {
		String[] nodes = new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I" };
		GrfDfsBfs grf = new GrfDfsBfs(9, nodes);
		grf.initGrf();
		grf.printMatrix();

		System.out.println("------ 深度優先遍歷(遞迴)開始 ------");
		grf.resetVisited();
		grf.dfsRecursive(0);
		System.out.println();
		System.out.println("------ 深度優先遍歷(遞迴)結束 ------");
		
		System.out.println("------ 深度優先遍歷(棧)開始 ------");
		grf.resetVisited();
		Stack<Integer> stack = new Stack<Integer>();
		stack.push(0);
		grf.matirx[0][0] = 1;
		System.out.print(grf.nodes[0]);
		grf.dfsStack(stack);
		System.out.println();
		System.out.println("------ 深度優先遍歷(棧)結束 ------");

		System.out.println("------ 廣度優先遍歷開始 ------");
		grf.resetVisited();
		Queue<Integer> queue = new LinkedList<Integer>();
		queue.add(0);
		grf.bfsQueue(queue);
		System.out.println();
		System.out.println("------ 廣度優先遍歷結束 ------");
	}

}
 

原創博文，轉載請註明出處。

右鍵，檢視圖片，看大圖。