Java编程：图

思路分析

代码实现

/**

• 对一个结点进行深度优先遍历算法

• @param isVisited 是否访问表示矩阵

• @param i 第i个结点 第一次是0

*/

private void dfs(boolean[] isVisited, int i) {

// 首先访问该节点

System.out.print(getValueByIndex(i) + “->”);

// 将该节点设置为已经访问

isVisited[i] = true;

// 查找结点i的第一个邻接节点

int w = getFirstNeighbor(i);

while (w != -1) {//说明有

if (!isVisited[w]) {

dfs(isVisited, w);

}

// 如果w存在，但是已经被访问过

w = getNextNeighbor(i, w);

}

}

// 对dfs重载 遍历所有结点，并进行dfs

public void dfs() {

isVisited = new boolean[vertexList.size()];

// 遍历所有的结点，进行dfs(回溯

for (int i = 0; i < getNumOfVertex(); i++) {

if (!isVisited[i]) {

dfs(isVisited, i);

}

}

}

广度优先遍历基本思想

---

图的广度优先搜索(Broad First Search) 。

类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

广度优先遍历算法步骤

1. 访问初始结点v并标记结点v为已访问。

2. 结点v入队列

3. 当队列非空时，继续执行，否则算法结束。

4. 出队列，取得队头结点u。

5. 查找结点u的第一个邻接结点w。

6. 若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：

6.1 若结点w尚未被访问，则访问结点w并标记为已访问。

6.2 结点w入队列

6.3 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

广度优先举例说明

广度优先代码实现

/**

• 对一个结点进行广度优先遍历算法

• @param isVisited 是否访问表示矩阵

• @param i 第i个结点 第一次是0

*/

private void bfs(boolean[] isVisited, int i) {

int u; // 表示队列头结点对应下标

int w; // 表示邻接节点w

// 队列，记录结点访问的顺序

LinkedList queue = new LinkedList<>();

// 访问结点，输出信息

System.out.print(getValueByIndex(i) + “=>”);

// 标记为已访问

isVisited[i] = true;

// 将节点加入队列

queue.addLast(i);

while (!queue.isEmpty()) {

// 出去队列头结点下标

u = queue.removeFirst();

// 得到第一个临界点下标w

w = getFirstNeighbor(u);

while (w != -1) { // 找到了

// 判断是否访问

if (!isVisited[w]) {

System.out.print(getValueByIndex(w) + “=>”);

// 标记已访问

isVisited[w] = true;

// 入队

queue.addFirst(w);

}

// 以u为前驱结点，找w后面的下一个邻接点

w = getNextNeighbor(u, w); // 体现出广度优先

}

}

}

// 对dfs重载 遍历所有结点，并进行dfs

public void bfs() {

isVisited = new boolean[vertexList.size()];

for (int i = 0; i < getNumOfVertex(); i++) {

if (!isVisited[i]) {

bfs(isVisited, i);

}

}

}

应用实例

---

图的完整代码

=================================================================

package graph;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.LinkedList;

public class Graph {

private ArrayList vertexList; // 存储顶点集合

private int[][] edges; // 存储图对应的邻接矩阵

private int numOfEdges; // 表示边的树木

private boolean[] isVisited;

public static void main(String[] args) {

// 测试图的创建

int n = 5; // 结点的个数

// String[] Vertexes = {“A”, “B”, “C”, “D”, “E”};

String[] Vertexes = {“1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”};

// 创建图对象

Graph graph = new Graph(8);

// 循环添加顶点

for (String Vertex : Vertexes) {

graph.insertVertex(Vertex);

}

// 添加边

// A-B A-C B-C B-D B-E

// graph.insertEdge(0, 1, 1); // A-B

// graph.insertEdge(0, 2, 1); // A-C

// graph.insertEdge(1, 2, 1); // B-C

// graph.insertEdge(1, 3, 1); // B-D

// graph.insertEdge(1, 4, 1); // B-E

graph.insertEdge(0, 1, 1);

graph.insertEdge(0, 2, 1);

graph.insertEdge(1, 3, 1);

graph.insertEdge(1, 4, 1);

graph.insertEdge(3, 7, 1);

graph.insertEdge(4, 7, 1);

graph.insertEdge(2, 5, 1);

graph.insertEdge(2, 6, 1);

graph.insertEdge(5, 6, 1);

graph.showGraph();

// 测试dfs遍历是否ok

System.out.println(“深度优先遍历”);

graph.dfs();

System.out.println();

// 测试bfs遍历是否ok

System.out.println(“广度优先遍历”);

graph.bfs();

}

/**

• 构造器

• @param n 图的结点数量

*/

public Graph(int n) {

// 初始化矩阵和ArrayList

edges = new int[n][n];

vertexList = new ArrayList(n);

numOfEdges = 0;

// isVisited = new boolean[5];

}

/**

• 插入结点（顶点）

• @param vertex 结点

*/

public void insertVertex(String vertex) {

vertexList.add(vertex);

}

/**

• 添加边

• @param v1 表示点的下标 即是第几个顶点 “A” - “B” => “A” - 0 “B” - 1

• @param v2 第二个顶点对应的下标

• @param weight 表示两个点是否有关联

*/

public void insertEdge(int v1, int v2, int weight) {

edges[v1][v2] = weight;

edges[v2][v1] = weight;

numOfEdges++;

}

/**

• 得到第index个结点的第一个邻接节点的下标w

• @param index 想寻求邻接节点的结点

• @return 找到返回下标，找不到返回-1

*/

public int getFirstNeighbor(int index) {

for (int i = 0; i < vertexList.size(); i++) {

if (edges[index][i] > 0) {

return i;

}

}

return -1;

}

/**

• 根据前一个邻接节点的下标获取下一个邻接节点

• @param v1 结点横坐标

• @param v2 结点纵坐标

• @return 找到返回下标，找不到返回-1

*/

public int getNextNeighbor(int v1, int v2) {

for (int i = v2 + 1; i < vertexList.size(); i++) {

if (edges[v1][i] > 0) {

return i;

}

}

return -1;

}

/**

• 对一个结点进行广度优先遍历算法

• @param isVisited 是否访问表示矩阵

• @param i 第i个结点 第一次是0

*/

private void bfs(boolean[] isVisited, int i) {

int u; // 表示队列头结点对应下标

int w; // 表示邻接节点w

// 队列，记录结点访问的顺序

LinkedList queue = new LinkedList<>();

// 访问结点，输出信息

System.out.print(getValueByIndex(i) + “=>”);

// 标记为已访问

isVisited[i] = true;

// 将节点加入队列

queue.addLast(i);

while (!queue.isEmpty()) {

// 出去队列头结点下标

u = queue.removeFirst();

// 得到第一个临界点下标w

w = getFirstNeighbor(u);

while (w != -1) { // 找到了

// 判断是否访问

if (!isVisited[w]) {

System.out.print(getValueByIndex(w) + “=>”);

// 标记已访问

isVisited[w] = true;

// 入队

queue.addFirst(w);

}

// 以u为前驱结点，找w后面的下一个邻接点

w = getNextNeighbor(u, w); // 体现出广度优先

}

}

}

// 对dfs重载 遍历所有结点，并进行dfs

public void bfs() {

isVisited = new boolean[vertexList.size()];

for (int i = 0; i < getNumOfVertex(); i++) {

if (!isVisited[i]) {

bfs(isVisited, i);

}

}

}

/**

• 对一个结点进行深度优先遍历算法

• @param isVisited 是否访问表示矩阵

• @param i 第i个结点 第一次是0

*/

private void dfs(boolean[] isVisited, int i) {

// 首先访问该节点

System.out.print(getValueByIndex(i) + “->”);

// 将该节点设置为已经访问

isVisited[i] = true;

// 查找结点i的第一个邻接节点

int w = getFirstNeighbor(i);

while (w != -1) {//说明有

if (!isVisited[w]) {

dfs(isVisited, w);

}

// 如果w存在，但是已经被访问过

w = getNextNeighbor(i, w);

}

}

// 对dfs重载 遍历所有结点，并进行dfs

public void dfs() {

isVisited = new boolean[vertexList.size()];

// 遍历所有的结点，进行dfs(回溯

for (int i = 0; i < getNumOfVertex(); i++) {

if (!isVisited[i]) {

dfs(isVisited, i);

}

}

}

// 图中常用的方法

/**

• 返回结点的个数

• @return 结点个数

*/

public int getNumOfVertex() {

return vertexList.size();

}

/**

• 返回边的个数

• @return 边的个数

*/

public int getNumOfEdges() {

return numOfEdges;

}

/**

• 返回结点i（下标） 对应的数据 0->“A” 1->“B” 2->“C”

• @param i 第i个

• @return 第i个数据

*/

public String getValueByIndex(int i) {