JAVA实践图的遍历

前言

图是什么？



图可以长这样。

如果将图看作一个省份，每个顶点就是一座城市，连接的线则是道路，要判断这个省内有几个城市，就需要每个城市跑一遍，确认其是存在（连通）的，然后纳入计数。

图在程序里如何表示

图最常使用的存储方法是二维数组，上面那幅图，长这样。

*      A1   B2   C3   D4    E5
* A1    0   1    1    ∞    1
* B2    1   0    ∞    1    ∞
* C3    1   ∞   0    ∞    1
* D4    ∞  1    ∞    0    ∞
* E5    1   ∞   1    ∞    0

这是一个5*5的二维数组

其中

A行A列为0，表示A到A本身

A行B列为1，表示从A可以到达B

A行C列为1，表示从A可以到达C

A行D列为∞，表示从A无法到达D

A行E列为1，表示从A可以到达E

其他行列的表示含义同上

两种方法

遍历图使用深度或者广度优先的遍历，首次遍历前选择一个点，然后以该点为起点进行扩展

深度优先

遍历过程:

* 深度优先：
*          A开始，检查第A行第一个可进入的顶点，[首先]搜索到有B    此时[A]已访问
*          进入B，检查B行第一个可进入的顶点，[首先]搜索到D     此时[A、B]已访问
*          进入D，检查D行可进入的顶点，无                         此时[A、B、D]已访问
*          回到B，搜索下一个可进入的顶点，无
*          回到A，搜索下一个可进入的顶点，有C
*          进入C，检查C行第一个可进入的顶点，有E                  此时[A、B、D、C]已访问
*          进入E，检查D行第一个可进入的顶点，无                   此时[A、B、D、C、E]已访问
*          所有顶点已访问，遍历结束

代码实现:

static void dfs(char startC) {
//输出每次访问的顶点
System.out.print(startC + " ");

//获取当前访问的字母在二维数组中的所在行数，需要减一对应角标
int line = getValue(startC) - 1;

//表示当前已访问的顶点数
sum++;

//给当前访问的顶点做标记
mark[line] = true;

//如果当前已访问顶点数已经等于最大顶点个数，那么遍历已经结束
if (sum == maxLine) {
System.out.println();
return;
}

//判断从line到row是否连通，如果是连通的，进入该点
for (int row = 0; row < maxRow; row++) {
if (map[line][row] == 1 && !mark[row]) {
dfs(getKey(row));
}
}
}

广度优先

遍历过程:

* 广度优先：
*          A入队，查看A所有可走路径，有B、C、E      此时[A]已访问
*          B、C、E入队，A出队，队列头为B
*          进入B，查看B所有可走路径，有D         此时[A、B]已访问
*          D入队，B出队，队列头尾C
*          进入C，查看C所有可走路径，有E         此时[A、B、C]已访问
*          但E已入队，跳过入队操作
*          进入E，查看所有可走路径，无           此时[A、B、C、E]已访问
*          E出队，队列头为D
*          进入D，查看所有可走路径，无           此时[A、B、C、E、D]已访问
*          D出队
*          遍历完成

代码实现:

static void bfs(char startC) {
char[] queue = new char[maxLine];
int head = 0;
int tail = 0;

//表示该字符所在行，因为数组角标为0开始，需要-1
int line = getValue(startC) - 1;

//首个字符入队
queue[tail++] = startC;

//表示该点已经被走过
mark[line] = true;

while (head < tail) {
//获取当前字符顶点在二维数组中的行数
line = getValue(queue[head]) - 1;

//查看该字符能到达的[所有]顶点
//即那一行有哪几个列的值为1
for (int row = 0; row < maxRow; row++) {

//判断是否已经走过
if (mark[row]) {
continue;
}

//如果为1表示能从line代表的字符到达row代表的字符
if (map[line][row] == 1) {

//将该字符入队
queue[tail++] = getKey(row);

//输出访问的点
System.out.print(queue[tail - 2] + "→");

//当前line代表的字符已经走过
mark[row] = true;
}
}

//队列已满表示全部经过遍历了
if (tail == maxLine) {
//输出最后一个访问的点
System.out.println(queue[tail - 1]);
return;
}
head++;
}
}

完整实现

public class TraversingMap {
//99999表示无穷大
static int[][] map = {
{0, 1, 1, 99999, 1},
{1, 0, 99999, 1, 99999},
{1, 99999, 0, 99999, 1},
{99999, 1, 99999, 0, 99999},
{1, 99999, 1, 99999, 0}
};
static char[] abc = new char[]{'A', 'B', 'C', 'D', 'E'};
static boolean[] mark;
static int maxLine = map.length;
static int maxRow = map[0].length;

public static void main(String[] args) {
mark = new boolean[maxLine];
bfs('C');

mark = new boolean[maxLine];
dfs('C');
}
static void bfs(char startC) {
char[] queue = new char[maxLine];
int head = 0;
int tail = 0;

//表示该字符所在行，因为数组角标为0开始，需要-1
int line = getValue(startC) - 1;

//首个字符入队
queue[tail++] = startC;

//表示该点已经被走过
mark[line] = true;

while (head < tail) {
//获取当前字符顶点在二维数组中的行数
line = getValue(queue[head]) - 1;

//查看该字符能到达的[所有]顶点
//即那一行有哪几个列的值为1
for (int row = 0; row < maxRow; row++) {

//判断是否已经走过
if (mark[row]) {
continue;
}

//如果为1表示能从line代表的字符到达row代表的字符
if (map[line][row] == 1) {

//将该字符入队
queue[tail++] = getKey(row);

//输出访问的点
System.out.print(queue[tail - 2] + "→");

//当前line代表的字符已经走过
mark[row] = true;
}
}

//队列已满表示全部经过遍历了
if (tail == maxLine) {
//输出最后一个访问的点
System.out.println(queue[tail - 1]);
return;
}
head++;
}
}
static int sum = 0;
static void dfs(char startC) {
//输出每次访问的顶点
System.out.print(startC + " ");

//获取当前访问的字母在二维数组中的所在行数，需要减一对应角标
int line = getValue(startC) - 1;

//表示当前已访问的顶点数
sum++;

//给当前访问的顶点做标记
mark[line] = true;

//如果当前已访问顶点数已经等于最大顶点个数，那么遍历已经结束
if (sum == maxLine) {
System.out.println();
return;
}

//判断从line到row是否连通，如果是连通的，进入该点
for (int row = 0; row < maxRow; row++) {
if (map[line][row] == 1 && !mark[row]) {
dfs(getKey(row));
}
}
}

//输入值获取字符
static char getKey(int value) {
return abc[value];
}
//输入字符获取值
static int getValue(char c) {
return c - 64;
}
}

结果

C→A→E→B→D
C A B D E

一点感想

代码写得真像一坨shit

HashMap无法通过value获取key，因为value可能重复导致多对一，然而谷歌有个库实现了只能一对一的Map，不过我并没有拿来用，直接粗暴的写了getValue，getKey偷懒。

一开始没想出深度优先遍历的结束条件，表明还是不熟悉嗯。

END