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