数据结构之—— 图

定义

是一种非线性表结构数据。图中的每个元素称为顶点（vertex），图中的顶点与其他任意顶点建立的连接称为边（edge）；。和顶点相连接的边的条数，称为度（degree）。
对于图来说，又可以分为有向图和无向图。有向图，顾名思义就是带有方向的图；在有向图中，又将度细分为出度（Out-degree）和入度（In-degree）

• 入度：表示有多少条边指向这个顶点。
• 出度：表示有多少条边以这个顶点为起点，指向外部。

无向图，就是没有方向的图；带权图（weighted graph）：就是边上增加权重分数的一种图。

图的表示方式

之前的文档就说过，所有的数据结构都是在数组和链表的基础上进行衍生出来的，所以图也不例外，图的的数据结构表示方式主要有两种邻接矩阵存储法（通过数组）和邻接表（Adjacency List）存储法（链表）

邻接矩阵存储法

邻接矩阵就是底层采用一个二维数组进行数据的存储。对于无向图来说，如果顶点i与顶点j之间有边，那么就可以记为a[i][j] = 1 和 a[j][i] = 1，如果是有向图，有从i指向j的边，就可以记为a[i][j] = 1，同理有从j指向i的边时，a[j][i] = 1;对于带权图，存储的值就是对应的数据值。

public class Graph {

    // 顶点个数
    private int v;
    // 邻接矩阵
    private int[][] adj = new int[4][4];

    /**
     * 无向图
     * @param s 起点
     * @param t 终点
     */
    public void addEdge(int s, int t) {
        adj[s][t] = 1;
        adj[t][s] = 1;
    }
    /**
     * 有向图
     */
    public void addDirectionEdge(int s, int t) {
        adj[s][t] = 1;
    }
}

• 优点：存储方式简单直接，底层使用数组，获取数据时，比较高效。
• 缺点：当存储的是**稀疏图（Sparse Matrix）**时，比较浪费内存空间。

邻接表存储法

邻接表，有点类似于散列表的存储方式。每个顶点对应一个链表，链表中存储的就是这个顶点指向的其他顶点数据，邻接表就是用时间换空间的思想，虽然节省了内存空间，但是对于链表来说，查询遍历就不是很方便了。

public class Graph {

    // 顶点个数
    private int v;

    // 邻接表
    private LinkedList<Integer> adj[];

    /**
     * 无向图
     * @param s 起点
     * @param t 终点
     */
    public void addEdge(int s, int t) {
        adj[s].add(t);
        adj[t].add(s);
    }
    /**
     * 有向图
     */
    public void addDirectionEdge(int s, int t) {
        adj[s].add(t);
    }
}

广度优先算法（Breadth-First-Search）

简称为BFS，其思想就是层层推进，先查找离中心点最近的点，然后次之的点，一层层向外查找的过程。其时间复杂度为O（V + E），V表示顶点数量，E表示边数，对于一个连通图来说，也就是每个顶点都会进行连接，那么边数E肯定大于V-1个，所以时间复杂度可以简写为O（E），空间复杂度是O（V），因为需要保存顶点的遍历，最多需要保存全部的顶点数据。

public class Graph {
    // 顶点的数
    private int v;

    // 邻接表
    private LinkedList<Integer> adj[];

    // 全局变量或者类成员变量
    private boolean found = false;

    public Graph(int v) {
        this.v = v;
        adj = new LinkedList[v];
        for (int i = 0; i < v; i++) {
            adj[i] = new LinkedList<>();
        }
    }

    // 无向图添加一条边
    public void addEdge(int s, int t) {
        adj[s].add(t);
        adj[t].add(s);
    }
    
    // 广度优先算法
    public void bfs(int s, int t) {
        if (s == t) {
            return;
        }
        // 用来记录被访问的顶点，防止重复访问
        boolean[] visited = new boolean[v];
        visited[s] = true;
        // 用来记录已经被访问，但相邻顶点还没被访问的数据
        Queue<Integer> queue = new LinkedList<>();
        queue.add(s);
        // 用来记录搜索的路径
        int[] prev = new int[v];
        for (int i = 0; i < v; ++i) {
            prev[i] = -1;
        }
        while (queue.size() != 0) {
            int w = queue.poll();
            for (int i = 0; i < adj[w].size(); i++) {
                int q = adj[w].get(i);
                // 判断节点是否已经被访问过
                if (!visited[q]) {
                    prev[q] = w;
                    if (q == t) {
                        print(prev, s, t);
                        return;
                    }
                    visited[q] = true;
                    queue.add(q);
                }
            }
        }
    }
    
    // 打印的方法
    private void print(int[] prev, int s, int t) {
        // 递归打印s->t的路径
        if (prev[t] != -1 && t != s) {
            print(prev, s, prev[t]);
        }
        System.out.print(t + " ");
    }
}

深度优先算法（Depth-First-Search）

简称DFS：其核心思想就是从一个点出发，一路向下执行，直到执行不通了，就返回上一个顶点，执行其他路径，直到找到对应的数据。时间复杂度为O（E），E表示边数，空间复杂度为O（V）。

// 全局变量或者类成员变量
private boolean found = false;

public void dfs(int s, int t) {
    found = false;
    boolean[] visited = new boolean[v];
    int[] prev = new int[v];
    for (int i = 0; i < v; ++i) {
        prev[i] = -1;
    }
    // 递归调用
    recurDfs(s, t, visited, prev);
    print(prev, s, t);
}

private void recurDfs(int w, int t, boolean[] visited, int[] prev) {
    if (found == true) {
        return;
    }
    visited[w] = true;
    if (w == t) {
        found = true;
        return;
    }
    for (int i = 0; i < adj[w].size(); i++) {
        int q = adj[w].get(i);
        if (!visited[q]) {
            prev[q] = w;
            recurDfs(q, t, visited, prev);
        }
    }
}