简介

在现实生活中，有许多应用场景会包含很多点以及点点之间的连接，而这些应用场景我们都可以用即将要学习的图这种数据结构去解决。

地图：

我们生活中经常使用的地图，基本上是由城市以及连接城市的道路组成，如果我们把城市看做是一个一个的点，把道路看做是一条一条的连接，那么地图就是我们将要学习的图这种数据结构。

电路图：

下面是一个我们生活中经常见到的集成电路板，它其实就是由一个一个触点组成，并把触点与触点之间通过线进行连接，这也是我们即将要学习的图这种数据结构的应用场景

图的定义及分类：

定义：图是由一组顶点和一组能够将两个顶点相连的边组成的

特殊的图：

1. 自环：即一条连接一个顶点和其自身的边；
2. 平行边：连接同一对顶点的两条边；

图的分类：

按照连接两个顶点的边的不同，可以把图分为以下两种：

无向图：边仅仅连接两个顶点，没有其他含义；

有向图：边不仅连接两个顶点，并且具有方向；

无向图

图的相关术语

相邻顶点：当两个顶点通过一条边相连时，我们称这两个顶点是相邻的，并且称这条边依附于这两个顶点。

度：某个顶点的度就是依附于该顶点的边的个数

子图：是一幅图的所有边的子集(包含这些边依附的顶点)组成的图；

路径：是由边顺序连接的一系列的顶点组成

环：是一条至少含有一条边且终点和起点相同的路径

连通图：如果图中任意一个顶点都存在一条路径到达另外一个顶点，那么这幅图就称之为连通图

连通子图：一个非连通图由若干连通的部分组成，每一个连通的部分都可以称为该图的连通子图

图的存储结构

要表示一幅图，只需要表示清楚以下两部分内容即可：

1. 图中所有的顶点；
2. 所有连接顶点的边；

常见的图的存储结构有两种：邻接矩阵和邻接表

邻接矩阵

1. 使用一个V*V的二维数组int[V][V] adj,把索引的值看做是顶点；
2. 如果顶点v和顶点w相连，我们只需要将adj[v][w]和adj[w][v]的值设置为1,否则设置为0即可。

很明显，邻接矩阵这种存储方式的空间复杂度是V^2的，如果我们处理的问题规模比较大的话，内存空间极有可能不够用。

邻接表

1.使用一个大小为V的数组 Queue[V] adj，把索引看做是顶点；

2.每个索引处adj[v]存储了一个队列，该队列中存储的是所有与该顶点相邻的其他顶点

很明显，邻接表的空间并不是是线性级别的，所以后面我们一直采用邻接表这种存储形式来表示图。

代码实现

图API设计：

/**
 * @author wen.jie
 * @date 2021/8/27 10:43
 * 无向图
 */
public class Graph {

    //顶点数目
    private final int V;
    //边的数目
    private int E;
    //邻接表
    private Queue<Integer>[] adj;

    //初始化
    public Graph(int v) {
        this.V = v;
        this.E = 0;
        this.adj = new Queue[v];
        for (int i = 0; i < adj.length; i++) {
            adj[i] = new Queue<>();
        }
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    //向图中添加一条边 v-w
    public void addEdge(int v, int w) {
        adj[v].enqueue(w);
        adj[w].enqueue(v);
        E++;
    }

    //获取和顶点v相邻的所有顶点
    public Queue<Integer> adj(int v) {
        return adj[v];
    }

}

图的搜索

在很多情况下，我们需要遍历图，得到图的一些性质，例如，找出图中与指定的顶点相连的所有顶点，或者判定某个顶点与指定顶点是否相通，是非常常见的需求。

有关图的搜索，最经典的算法有深度优先搜索和广度优先搜索，接下来我们分别讲解这两种搜索算法。

深度优先搜索

所谓的深度优先搜索，指的是在搜索时，如果遇到一个结点既有子结点，又有兄弟结点，那么先找子结点，然后找 兄弟结点。

很明显，在由于边是没有方向的，所以，如果4和5顶点相连，那么4会出现在5的相邻链表中，5也会出现在4的相邻链表中，那么为了不对顶点进行重复搜索，应该要有相应的标记来表示当前顶点有没有搜索过，可以使用一个布尔类型的数组 boolean[V] marked,索引代表顶点，值代表当前顶点是否已经搜索，如果已经搜索，标记为true， 如果没有搜索，标记为false；

api设计：

代码实现：

/**
 * dfs:深度优先搜索
 * @author wen.jie
 * @date 2021/8/27 11:08
 */
public class DepthFirstSearch {
    //索引代表顶点，值代表当前顶点是否已经被搜索
    private boolean[] marked;
    //记录有多少顶点与s顶点相通
    private int count;

    public DepthFirstSearch(Graph G, int s) {
        this.marked = new boolean[G.V()];
        dfs(G, s);
    }

    //深度优先搜索找出G图中v顶点的所有相通顶点
    private void dfs(Graph G, int v) {
        //标为已搜索
        marked[v] = true;
        for (int w : G.adj(v)) {
            if (!marked(w))
                dfs(G, w);
        }
        count++;
    }

    //判断w顶点与s顶点是否相通
    public boolean marked(int w){
        return marked[w];
    }

    //获取与顶点s相通的所有顶点的总数
    public int count() {
        return this.count;
    }
}

构造如下的图，并测试：

    private Graph graph = new Graph(13);
    {
        graph.addEdge(0, 5);
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(0, 6);
        graph.addEdge(6, 4);
        graph.addEdge(4, 3);
        graph.addEdge(4, 5);
        graph.addEdge(5, 3);
        graph.addEdge(7, 8);
        graph.addEdge(9, 10);
        graph.addEdge(9, 11);
        graph.addEdge(9, 12);
        graph.addEdge(11, 12);
    }


    @Test
    public void test1() {
        DepthFirstSearch dfs = new DepthFirstSearch(graph, 0);
        int count = dfs.count();
        System.out.println("与起点0相通的顶点数量为："+ count);
        System.out.println(dfs.marked(5));
        System.out.println(dfs.marked(7));
    }

广度优先搜索

所谓的广度优先搜索，指的是在搜索时，如果遇到一个结点既有子结点，又有兄弟结点，那么先找兄弟结点，然后找子结点。

api设计：

代码实现：

/**
 * @author wen.jie
 * @date 2021/8/27 13:43
 * bfs:广度优先遍历
 */
public class BreadthFirstSearch {

    //索引代表顶点，值代表当前顶点是否已经被搜索
    private boolean[] marked;
    //记录有多少顶点与s顶点相通
    private int count;
    //用来存储待搜索邻接表的点
    private Queue<Integer> waitSearch;

    public BreadthFirstSearch(Graph G, int s) {
        this.marked = new boolean[G.V()];
        this.waitSearch = new Queue<>();
        bfs(G, s);
    }

    //深度优先搜索找出G图中v顶点的所有相通顶点
    private void bfs(Graph G, int v) {
        marked[v] = true;
        //入队列,待搜索
        waitSearch.enqueue(v);
        while (!waitSearch.isEmpty()) {
            //出队列
            Integer wait = waitSearch.dequeue();
            for (Integer w : G.adj(wait)) {
                if (!marked[w]) {
                    bfs(G, w);
                }
            }
        }
        count++;
    }

    //判断w顶点与s顶点是否相通
    public boolean marked(int w){
        return marked[w];
    }

    //获取与顶点s相通的所有顶点的总数
    public int count() {
        return this.count;
    }

}

测试：

    @Test
    public void test2() {
        BreadthFirstSearch bfs = new BreadthFirstSearch(graph, 0);
        int count = bfs.count();
        System.out.println("与起点0相通的顶点数量为："+ count);
        System.out.println(bfs.marked(5));
        System.out.println(bfs.marked(7));
    }

路径查找

在实际生活中，地图是我们经常使用的一种工具，通常我们会用它进行导航，输入一个出发城市，输入一个目的地城市，就可以把路线规划好，而在规划好的这个路线上，会路过很多中间的城市。这类问题翻译成专业问题就是： 从s顶点到v顶点是否存在一条路径？如果存在，请找出这条路径。

例如在上图上查找顶点0到顶点4的路径用红色标识出来,那么我们可以把该路径表示为 0-2-3-4。

深度优先遍历查找路径

思路：

我们实现路径查找，最基本的操作还是得遍历并搜索图，所以，我们的实现暂且基于深度优先搜索来完成。其搜索的过程是比较简单的。我们添加了edgeTo[]整型数组，这个整型数组会记录从每个顶点回到起点s的路径。 如果我们把顶点设定为0，那么它的搜索可以表示为下图：

代码实现如下：

public class DepthFirstPaths {
    // 索引代表顶点，值表示当前顶点是否已经被搜索
    private boolean[] marked;
    //起点
    private int s;
    //索引代表顶点，值代表从起点s到当前顶点路径上的最后一个顶点
    private Integer[] edgeTo;

    public DepthFirstPaths(Graph G,int s){
        this.marked = new boolean[G.V()];
        this.s = s;
        this.edgeTo = new Integer[G.V()];
        dfs(G, s);
    }

    private void dfs(Graph G, int v){
        marked[v] = true;
        for (Integer w : G.adj(v)) {
            if(!marked[w]) {
                //到达顶点w的路径上的最后一个顶点是v
                edgeTo[w] = v;
                dfs(G, w);
            }
        }
    }

    //判断v顶点与s顶点是否存在路径
    public boolean hasPathTo(int v){
        return marked[v];
    }

    //找出从起点s到顶点v的路径(就是该路径经过的顶点)
    public Stack<Integer> pathTo(int v){

        if (!hasPathTo(v))
            return null;
        Stack<Integer> path = new Stack<>();
        path.push(v);
        while (edgeTo[v] != null) {
            int p = edgeTo[v];
            path.push(p);
            v = p;
        }
        return path;
    }
}

测试：

    private Graph graph = new Graph(6);
    {
        graph.addEdge(0,2);
        graph.addEdge(2,1);
        graph.addEdge(2,3);
        graph.addEdge(0,1);
        graph.addEdge(0,5);
        graph.addEdge(3,5);
        graph.addEdge(3,4);
        graph.addEdge(2,4);
    }

    @Test
    public void test() {
        DepthFirstPaths paths = new DepthFirstPaths(graph, 0);
        Stack<Integer> path = paths.pathTo(4);
        for (Integer integer : path) {
            System.out.println(integer);
        }
    }

广度优先遍历查找路径

深度优先搜索得到的路径不仅取决于图的结构，还取决于图的表示和递归调用的性质。

对于找出最短路径的那条，我们可以使用广度优先遍历（BFS）。

结合上面的深度优先遍历查找路径和前面广度优先搜索代码，不难得出广度优先遍历查找路径的代码：

/**
 * @author wen.jie
 * @date 2021/8/27 14:52
 */
public class BreadthFirstPaths {

    //索引代表顶点，值代表当前顶点是否已经被搜索
    private boolean[] marked;
    //记录有多少顶点与s顶点相通
    private int count;
    //用来存储待搜索邻接表的点
    private Queue<Integer> waitSearch;
    //索引代表顶点，值代表从起点s到当前顶点路径上的最后一个顶点
    private Integer[] edgeTo;

    public BreadthFirstPaths(Graph G, int s) {
        this.marked = new boolean[G.V()];
        this.waitSearch = new Queue<>();
        this.edgeTo = new Integer[G.V()];
        bfs(G, s);
    }

    //深度优先搜索找出G图中v顶点的所有相通顶点
    private void bfs(Graph G, int v) {
        //标记起点
        marked[v] = true;
        //入队列,待搜索
        waitSearch.enqueue(v);
        while (!waitSearch.isEmpty()) {
            //出队列
            Integer wait = waitSearch.dequeue();
            for (Integer w : G.adj(wait)) {
                if (!marked[w]) { //对于每个未被标记的相邻顶点
                    edgeTo[w] = wait; //保存最短路径的最后一条边
                    marked[w] = true; //标记，因为最短路径已知
                    waitSearch.enqueue(w); //入队列
                }
            }
        }
        count++;
    }

    //判断w顶点与s顶点是否相通
    public boolean hasPathTo(int w){
        return marked[w];
    }

    //获取与顶点s相通的所有顶点的总数
    public int count() {
        return this.count;
    }

    //找出从起点s到顶点v的路径(就是该路径经过的顶点)
    public Stack<Integer> pathTo(int v){

        if (!hasPathTo(v))
            return null;
        Stack<Integer> path = new Stack<>();
        path.push(v);
        while (edgeTo[v] != null) {
            int p = edgeTo[v];
            path.push(p);
            v = p;
        }
        return path;
    }

}

测试：

        BreadthFirstPaths paths = new BreadthFirstPaths(graph, 1);
        Stack<Integer> path = paths.pathTo(3);
        for (Integer integer : path) {
            System.out.println(integer);
        }

下面是广度优先遍历的处理样图：

命题：对于从s可达的任意顶点v，广度优先搜索都能找到一条从s到v的最短路径（没有其他从s到v的路径所含的边比这条路径更少）

证明：由归纳易得队列总是包含零个或多个到起点的距离为k的顶点，之后是零个或多个到起点的举例为k+1的顶点，其中k为整数，起始值为0。这意味着顶点是按照它们和s的距离的顺序加入队列或者离开队列的。从顶点v加入队列到它离开队列之前，不可能找出到v的更短的路径，而在v离开队列之后发现的所有能够到达v的路径不可能短于v在树中的路径长度。

本篇所有代码均已上传至：https://gitee.com/wj204811/algorithm

无向图