图

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

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

电路图

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

图的定义及分类

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

特殊的图

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

图的分类

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

• 无向图：边仅仅连接两个顶点，没有其他含义
• 有向图：边不仅连接两个顶点，并且具有方向

无向图

图的相关术语

相邻顶点

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

度

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

子图

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

路径

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

环

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

连通图

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

连通子图

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

图的存储结构

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

• 图中所有的顶点
• 所有连接顶点的边

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

邻接矩阵

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

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

邻接表

• 使用一个大小为V的数组 Queue[V] adj，把索引看做是顶点；
• 每个索引处adj[v]存储了一个队列，该队列中存储的是所有与该顶点相邻的其他顶点
  

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

图的实现

图的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: 邻接表

代码实现

package com.vmware;

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * @apiNote 基于临接表的图实现
 */
public class Graph {
    //顶点数目
    private int V;
    //边的数目
    private int E;
    //临接表
    private Queue<Integer>[] adj;

    public Graph(int V) {
        this.V = V;
        this.E = 0;
        this.adj = new ArrayDeque[V];
        //init queue
        for (int i = 0; i < this.adj.length; i++) {
            this.adj[i] = new ArrayDeque<>();
        }
    }

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

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

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

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

图的搜索

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

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

深度优先搜索

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

很明显，在由于边是没有方向的，所以，如果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顶点相通

代码实现

package com.vmware;

/**
 * @apiNote 深度优先搜索实现
 */
public class DepthFirstSearch {
    //索引代表顶点，value表示当前顶点是否已经被搜索
    private boolean[] marked;
    //记录有多少顶点与s顶点相通
    private int count;

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

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

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

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

广度优先搜索

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

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: 用来存储待搜索邻接表的点

代码实现

package com.vmware;

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * @apiNote 图的深度优先搜索实现
 */
public class BreadthFirstSearch {
    private boolean[] marked;//索引代表顶点，值表示当前顶点是否被搜索

    private int count; //记录有多少个顶点与s顶点相通

    private Queue<Integer> waitSearch;//用来存储待搜索临接表的点

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

    //使用广度优先搜索找出图中v顶点的所有相邻顶点
    private void bfs(Graph graph, int v) {
        //标记顶点v为已搜索
        marked[v] = true;
        //添加待搜索顶点到队列中，等待搜索ta的邻接表
        waitSearch.add(v);
        while (!waitSearch.isEmpty()) {
            //从队列中弹出待搜索元素
            Integer s = waitSearch.poll();
            //获取顶点的临节点队列进行遍历
            for (Integer w : graph.adj(s)) {
                //如果临节点是没有被访问过的，则对其进行访问添加到队列，并标记
                if (!marked[w]) {
                    marked[w] = true;
                    waitSearch.add(w);
                    count++;
                }
            }
        }
    }

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

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