[067] Java “图”

1、图

• 1、为什么要用图：线性表局限于一个前驱一个后继，树只能有一个前驱（父节点），这两种数据结构可表征的结构形式较为简单，无法表示多对多的关系；
• 2、什么是图：一种数据结构，其中的节点可具有零个或多个相邻元素；两个节点之间的连线称为边，节点也称顶点；
• 
• 3、分类：
  • ① 无向图（undirected graph）：一个图结构中，所有的边都没有方向性；
  • 
  • ② 有向图（directed graph）：一个图结构中，边有方向性；
  • 
  • ③ 带权图：一个图结构中，边具有权值；也称为网；
  • 
• 4、图的表示方式：
  • 
  • ① 邻接表：即使用链表数组，为每个顶点保存一个链表，链表的每个节点代表一个连接到该顶点的其他顶点；
  • 
  • ② 邻接矩阵：即使用二维数组表示顶点之间的相邻关系，顶点i和j之间若存在一条边，则元素（i, j）的值为1，否则为0；
  • 
• 5、图的遍历方式：
  • ① 深度优先遍历DFS（Depth First Search）：类似于树的前、中、后序遍历，首先以一个未被访问过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点；当没有未访问过的顶点时，则回到上一个顶点，继续试探别的顶点，直至所有的顶点都被访问过。特点是“不撞南墙不回头”。
  • 
  • ② 广度优先遍历BFS（Broad First Search）​​​​​​​：类似于树的层遍历，把当前顶点的所有邻接顶点访问完，再依照此逻辑访问其他顶点。
  • 
     

2、Java 代码 -- 图的创建，添加顶点，深度及广度优先遍历

package DataStructures.Graph;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

/**
 * @author yhx
 * @date 2020/10/29
 */
public class Graph {
    /**
     * 存储顶点集合
     */
    private final ArrayList<String> vertexList;
    /**
     * 存储图对应的邻接矩阵
     */
    private final int[][] edges;
    /**
     * 边的数目
     */
    private int numOfEdges;
    /**
     * 记录某个顶点是否被访问过
     */
    private boolean[] isVisited;

    public static void main(String[] args) {
        // 顶点个数及对应的名称
        int n = 8;
        String[] Vertex = {"A", "B", "C", "D", "E", "F", "G", "H"};

        Graph graph = new Graph(n);

        // 添加节点
        for (String vertex : Vertex) {
            graph.insertVertex(vertex);
        }
        // 添加边 A-B A-C B-C B-D 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);


        System.out.println("图的邻接矩阵为：");
        graph.showGraph();
        System.out.println();

        // 深度优先遍历
        System.out.println("深度优先遍历dfs：");
        graph.dfs();
        System.out.println();
        System.out.println();

        // 广度优先遍历
        System.out.println("广度优先遍历bfs：");
        graph.bfs();

    }

    /**
     * 构造器
     *
     * @param n 顶点个数
     */
    public Graph(int n) {
        edges = new int[n][n];
        vertexList = new ArrayList<>(n);
        numOfEdges = 0;
        isVisited = new boolean[n];
    }

    /**
     * 插入节点
     *
     * @param vertex 节点名
     */
    public void insertVertex(String vertex) {
        vertexList.add(vertex);
    }

    /**
     * 添加边
     *
     * @param v1     顶点1对应的下标
     * @param v2     顶点2对应的下标
     * @param weight 权值，表示两个顶点互相关联
     */
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

    /**
     * 返回顶点个数
     *
     * @return 顶点个数
     */
    public int getNumOfVertex() {
        return vertexList.size();
    }

    /**
     * 返回边的个数
     *
     * @return 边的个数
     */
    public int getNumOfEdges() {
        return numOfEdges;
    }

    /**
     * 返回顶点i对应的名称
     *
     * @param i 顶点的下标
     * @return 顶点名称
     */
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

    /**
     * 返回两个顶点之间的权值
     *
     * @param v1 顶点1对应的下标
     * @param v2 顶点2对应的下标
     * @return 权值
     */
    public int getWeight(int v1, int v2) {
        return edges[v1][v2];
    }

    /**
     * 显示邻接矩阵
     */
    public void showGraph() {
        // 逐行取出
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * 得到指定顶点的第一个邻接顶点的下标w
     *
     * @param index 指定顶点的索引
     * @return 存在即返回下标，否则返回-1
     */
    public int getFirstNeighbor(int index) {
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    /**
     * 根据前一个邻接顶点v2的下标获取下一个邻接顶点v1的下标
     *
     * @param v1 下一个邻接顶点
     * @param v2 前一个邻接顶点
     * @return 返回下一个邻接顶点的下标，不存在返回-1
     */
    public int getNextNeighbor(int v1, int v2) {
        for (int j = v2 + 1; j < vertexList.size(); j++) {
            if (edges[v1][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    /**
     * 深度优先遍历算法dfs，遍历顶点i的所有邻接顶点
     *
     * @param isVisited 是否被访问的状态数组
     * @param i         第i个顶点
     */
    private void dfs(boolean[] isVisited, int i) {
        // 首先访问该顶点
        System.out.print(getValueByIndex(i) + "->");
        // 将顶点设置为已经访问
        isVisited[i] = true;
        // 查找顶点i的第一个邻接顶点w
        int w = getFirstNeighbor(i);
        // 如果找到第一个邻接顶点，就递归的查找邻接顶点的下一个邻接顶点
        while (w != -1) {
            if (!isVisited[w]) {
                dfs(isVisited, w);
            }
            // 如果w顶点已经被访问过，就跳过w访问w的下一个顶点i
            w = getNextNeighbor(i, w);
        }
    }

    /**
     * 重载dfs深度优先遍历算法，遍历所有顶点的邻接顶点
     */
    public void dfs() {
        // 遍历所有的节点，进行dfs[回溯]
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                dfs(isVisited, i);
            }
        }
    }

    /**
     * 对顶点i进行bfs广度优先遍历
     *
     * @param isVisited 是否被访问过
     * @param i         顶点i
     */
    private void bfs(boolean[] isVisited, int i) {
        // 队列的头顶点对应的下标
        int u;
        // 邻接顶点w
        int w;
        // 记录顶点的访问顺序
        LinkedList<Integer> 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.addLast(w);
                }
                // 如果w已经访问过，就以u为前驱点，找w之后的下一个邻接顶点
                w = getNextNeighbor(u, w);
            }
        }
    }

    /**
     * 重载bfs广度优先遍历算法，遍历所有顶点的邻接顶点
     */
    public void bfs() {
        isVisited = new boolean[8];
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                bfs(isVisited, i);
            }
        }
    }
}

3、运行结果

图的邻接矩阵为：
[0, 1, 1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 1, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0]

深度优先遍历dfs：
A->B->D->H->E->C->F->G->

广度优先遍历bfs：
A->B->C->D->E->F->G->H->