无向图、深度优先搜索(无向图)、广度优先搜索(无向图)、无向图路径查找(基于深度优先搜索)

一、无向图

1.1 图的相关术语

相邻顶点：

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

度：

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

子图：

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

路径：

是由边顺序连接的一系列的顶点组成。

环：

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

连通图：

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

连通子图：

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

1.2 图的存储结构

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

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

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

1.2.1 邻接矩阵

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

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

1.2.2 邻接表

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

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

很明显，邻接表的空间并不是是线性级别的

1.3 图的实现

1.3.1 图的API设计

类名	Graph
构造方法	Graph(int V)：创建一个包含V个顶点但不包含边的图
成员方法	1.public int V():获取图中顶点的数量 2.public int E():获取图中边的数量 3.public void addEdge(int v,int w):向图中添加一条边 v-w 4.public Queue adj(int v)：获取和顶点v相邻的所有顶点
成员变量	1.private final int V: 记录顶点数量 2.private int E: 记录边数量 3.private Queue[] adj: 邻接表

1.3.2 代码实现

package cn.itcast.algorithm.graph;

import cn.itcast.algorithm.linear.Queue;

/**
 * 无向图
 */
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 < V; i++) {
            adj[i] = new Queue<Integer>();
        }
    }

    // 获取顶点的数目
    public int V() {
        return V;
    }

    // 获取边的数目
    public int E() {
        return E;
    }

    // 向图中添加一条边 v-w
    public void addEdge(int v, int w) {
        // 无向图中边是无方向的，所以可以说该边是从v到w的，也可以说是从w到v的，所以要让w出现在v的邻接表中，也要让v出现在w的邻接表中
        adj[v].enqueue(w);
        adj[w].enqueue(v);
        // 边的数量+1
        E++;
    }

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

}

1.4 图的搜索

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

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

1.4.1 深度优先搜索

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

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

API设计：

类名	DepthFirstSearch
构造方法	DepthFirstSearch(Graph G,int s)：构造深度优先搜索对象，使用深度优先搜索找出G图中s顶点的所有相通顶点
成员方法	1.private void dfs(Graph G, int v)：使用深度优先搜索找出G图中v顶点的所有相通顶点 2.public boolean marked(int w):判断w顶点与s顶点是否相通 3.public int count():获取与顶点s相通的所有顶点的总数
成员变量	1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索 2.private int count：记录有多少个顶点与s顶点相通

代码：

/**
 * 深度优先搜索--无向图
 */
public class DepthFirstSearch {
    // 索引代表顶点，值表示当前顶点是否已经被搜索
    private boolean[] marked;
    // 记录有多少个顶点与s顶点相通
    private int count;

    //构造深度优先搜索对象，使用深度优先搜索找出G图中s顶点的所有相邻顶点
    public DepthFirstSearch(Graph G, int s) {
        // 初始化与s顶点相通的顶点的个数
        this.count = 0;
        // 创建一个和图的顶点数一样大小的布尔数组
        this.marked = new boolean[G.V()];
        // 搜索G图中与顶点s相同的所有顶点
        dfs(G, s);
    }

    // 使用深度优先搜索找出G图中v顶点的所有相邻顶点
    private void dfs(Graph G, int v) {
        // 将当前结点标记为true
        marked[v] = true;
        // 遍历v顶点的邻接表，得到每一个顶点w
        for (Integer w : G.adj(v)) {
            // 如果当前顶点w没有被搜索过，则递归搜索与w顶点相通的其他顶点
            if (!marked[w]) {
                // 相通的顶点数量+1
                count++;
                dfs(G, w);
            }
        }
    }

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

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

1.4.2 广度优先搜索

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

API设计：

类名	BreadthFirstSearch
构造方法	BreadthFirstSearch(Graph G,int s)：构造广度优先搜索对象，使用广度优先搜索找出G图中s顶点的所有相邻顶点
成员方法	1.private void bfs(Graph G, int v)：使用广度优先搜索找出G图中v顶点的所有相邻顶点 2.public boolean marked(int w):判断w顶点与s顶点是否相通 3.public int count():获取与顶点s相通的所有顶点的总数
成员变量	1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索 2.private int count：记录有多少个顶点与s顶点相通 3.private Queue waitSearch: 用来存储待搜索邻接表的点

代码：

/**
 * 广度优先搜索--无向图
 */
public class BreadthFirstSearch {
    // 索引代表顶点，值表示当前顶点是否已经被搜索
    private boolean[] marked;
    // 记录有多少个顶点与s顶点相通
    private int count;
    // 用来存储待搜索邻接表的点
    private Queue<Integer> waitSearch;

    // 构造广度优先搜索对象，使用广度优先搜索找出G图中s顶点的所有相邻顶点
    public BreadthFirstSearch(Graph G, int s) {
        // 初始化与s顶点相通的顶点的个数
        this.count = 0;
        // 创建一个和图的顶点数一样大小的布尔数组
        this.marked = new boolean[G.V()];
        // 初始化待搜索顶点的队列
        waitSearch = new Queue<Integer>();
        // 搜索G图中与顶点v相通的所有顶点
        dfs(G, s);
    }

    // 使用广度优先搜索找出G图中v顶点的所有相邻顶点
    private void dfs(Graph G, int v) {
        // 将当前顶点标记为true
        marked[v] = true;
        // 将当前顶点v入队列，待搜索
        waitSearch.enqueue(v);
        // 队列不为空，则从队列中弹出一个待搜索的顶点进行搜索
        while (!waitSearch.isEmpty()) {
            // 弹出待搜索的顶点
            Integer wait = waitSearch.dequeue();
            // 遍历当前顶点的连通顶点
            for (Integer w : G.adj(wait)) {
                // 未被搜索过的顶点进行入队列，并进行已搜索标识
                if (!marked(w)) {
                    waitSearch.enqueue(w);
                    marked[w] = true;
                    // 连通顶点数量+1
                    count++;
                }
            }
        }
    }

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

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

1.5 路径查找

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

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

1.5.1 路径查找API设计

类名	DepthFirstPaths
构造方法	DepthFirstPaths(Graph G,int s)：构造深度优先搜索对象，使用深度优先搜索找出G图中起点为s的所有路径
成员方法	1.private void dfs(Graph G, int v)：使用深度优先搜索找出G图中v顶点的所有相邻顶点 2.public boolean hasPathTo(int v):判断v顶点与s顶点是否存在路径 3.public Stack pathTo(int v):找出从起点s到顶点v的路径(就是该路径经过的顶点)
成员变量	1.private boolean[] marked: 索引代表顶点，值表示当前顶点是否已经被搜索 2.private int s:起点 3.private int[] edgeTo:索引代表顶点，值代表从起点s到当前顶点路径上的最后一个顶点

1.5.2 路径查找的实现

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

根据最终edgeTo的结果，我们很容易能够找到从起点0到任意顶点的路径；

/**
 * 无向图--深度优先搜索路径
 */
public class DepthFirstPaths {
    // 索引代表顶点，值表示当前顶点是否已经被搜索
    private boolean[] marked;
    // 起点
    private int s;
    // 索引代表顶点，值代表深度优先搜索条件下的其上一个顶点
    private int[] edgeTo;

    // 构造深度优先搜索对象，使用深度优先搜索找出G图中起点为s的所有路径
    public DepthFirstPaths(Graph G, int s) {
        // 创建一个和图的顶点数一样大小的布尔数组
        this.marked = new boolean[G.V()];
        // 创建一个和图顶点数一样大小的整型数组
        this.edgeTo = new int[G.V()];
        // 初始化顶点
        this.s = s;
        // 搜索G图中起点为s的所有路径
        dfs(G, s);
    }

    // 使用深度优先搜索找出G图中v顶点的所有相邻顶点，并为其指定上一个顶点
    private void dfs(Graph G, int v) {
        // 将当前结点标记为true
        marked[v] = true;
        // 遍历v顶点的邻接表，得到每一个顶点w
        for (Integer w : G.adj(v)) {
            // 如果当前顶点w没有被搜索过，则递归搜索与w顶点相通的其他顶点，并指定其上一个顶点
            if (!marked[w]) {
                // 指定其上一个顶点
                edgeTo[w] = v;
                dfs(G, w);
            }
        }
    }

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

    // 找出从起点s到顶点v的路径(就是该路径经过的顶点)
    public Stack<Integer> pathTo(int v) {
        // 如果当前顶点与起点s不连通，直接返回null
        if (!hasPathTo(v)) {
            return null;
        }
        // 定义一个栈，用来记录路径中经过顶点的容器
        Stack<Integer> path = new Stack<>();
        // 将v顶点存进栈中，使用逆推法，从edgeTo中找出上一个顶点存入栈中，直至找到起点s为止
        for (int i = v; i != s; i = edgeTo[i]) {
            // 将当前顶点压进栈中
            path.push(i);
        }
        // 把起点压入栈中
        path.push(s);
        return path;
    }
}