邻接矩阵 & 邻接表

基础内容

首先声明，以下情况暂且不讨论：
1）边的权值 不大于0
2）存在平行边
3）自环

有向图 和 无向图

有向图
如下，该图是一个有向图，每条边都有出发的点和指向的点，每条边都是有向的。

无向图
如下，有一个无向图（左图），每条边对应的两个点都可以互相抵达。那么我们可以将它看作是有向图（右图）

无权图 和 带权图

上面介绍的图都是无权图，每条边都不带权值，或者你可以认为每条边的权值都一样。接下来，所介绍的有权图的边的权值默认大于 0。

1）有向带权图：

2）无向带权图
可以看作是将图中 无向带权边 转换为 两条方向相反且权值相等的有向边。

图的表示方式

这里介绍 常见的两种表现形式：
1）邻接矩阵
2）邻接表
还有一种方式：链式前向星 ，此处暂不做介绍。

1）邻接矩阵

有向图

对于 有 n 个顶点（编号从 0 到 n-1）的有向图，我们可以维护一个 大小为 n x n 二维矩阵 int[][] g
在 不带权的图中：

g[x][y] = 0 时，表示 没有 x 到 y 的边，x 和 y表示顶点编号
g[x][y] = 1 时，表示 存在 x 到 y 的边

在 带权的图 中（此处默认 边的权值 大于 0）

g[x][y] = 0 时，表示 没有 x 到 y 的边，x 和 y表示顶点编号
g[x][y] > 0 时，表示 存在 x 到 y 的边，且这条边的权值为 g[x][y]

无向图

对于 有 n 个顶点（编号从 0 到 n-1）的无向图，我们可以将 每条无向带权边 看成 两条方向相反的有向带权边

那么无向图中， x 与 y 权值为 w 的边，可以如下表示（无权则 w 可以置为 1）：
g[x][y] = w; // 表示 x 到 y 权值为 w
g[y][x] = w; // 表示 y 到 x 权值为 w

代码实现：

有向图

// 有向图 邻接矩阵
public class Code01_createBy_AdjacencyMatrix01 {

    public static int n; //顶点个数

    public static int[][] g; // 邻接矩阵

    // 初始化
    public static void init() {
        g = new int[n][n];
    }

    // 有向图中，添加 一条 x 到 y 的边，权值为 w
    // 若是 无权图， w 大于 0即可，一般为 1
    public static void addEdge_01(int x, int y, int w) {
        g[x][y] = w;
    }

    // 无向图中，添加 一条 x 与 y 的边，权值为 w，看成双向的边即可
    // 若是 无权图，w 大于 0即可，一般为 1
    public static void addEdge_02(int x, int y, int w) {
        g[x][y] = w;
        g[y][x] = w;
    }

    public static void printGraph() {
        System.out.print("x\\y");
        for (int i = 0; i < n; i++) {
            System.out.printf("%3d ", i);
        }
        System.out.println();
        for (int x = 0; x < n; x++) {

            System.out.print(x + " [");

            for (int y = 0; y < n; y++) {
                System.out.printf("%3d ", g[x][y]);
            }
            System.out.println("]");
        }
    }

    public static void main(String[] args) {
        n = 5;
        init();

        addEdge_01(0, 1, 8);
        addEdge_01(0, 4, 7);
        addEdge_01(1, 4, 11);
        addEdge_01(2, 1, 12);
        addEdge_01(2, 3, 5);
        addEdge_01(3, 2, 8);
        addEdge_01(4, 3, 9);

        printGraph();
    }
}

运行结果：

无向图

// 无向图 邻接矩阵
class Code01_createBy_AdjacencyMatrix02 {

    int n; //顶点个数

    int[][] g; //邻接矩阵

    // 初始化
    void init() {
        g = new int[n][n];
    }

    // 无向图中，添加 一条 x 与 y 的边，权值为 w，看成双向的边即可
    // 若是 无权图，w 大于 0即可，一般为 1
    void addEdge_02(int x, int y, int w) {
        g[x][y] = w;
        g[y][x] = w;
    }
}

2）邻接表

n 个顶点（编号从 0 到 n-1）的有向图 中，对于每个顶点 x ， 将边 x -> y 中的 每个 顶点 y 存储到一个列表中，那么这个列表里所包含的顶点 就是 x 能直接 到达的点，或者说 x 与 这些点 相邻（有边）。
对于 每个顶点 都拥有一个列表，来记录其相邻顶点的信息。
我们将这些列表的引用记录到数组g[]中，那么数组 g[] 的大小也应为 n，下标为 0 到 n-1，与顶点编号相对应。
可以理解为 数组 + 列表。

有向图

在不带权的图中：
List<Integer>[] g;
g[x].add(y); // 加边 x -> y

那么带权呢，这时我们需要同时 记录 x 的 相邻顶点y 和 这条边的权值 w。
我们可以用数组记录，也可以用类（Pair）记录…方式有很多种，下面介绍 用数组记录的方式。
List<int[]>[] g;
g[x].add(new int[]{y, w}); // 加边 x -> y 权值为 w

无向图

在之前的介绍中，我们将无向图 视为 有向图进行处理，每条无向边 视为 两条 有向边。此处也是同理，就不再赘述。

代码实现

1）无权图

import java.util.ArrayList;
import java.util.List;

public class Code02_createBy_AdjacencyList1 {

    public static int n; //顶点个数

    public static List<Integer>[] g; //邻接表

    // 初始化
    public static void init() {
        g = new ArrayList[n];
        // Arrays.setAll(g, i -> new ArrayList<>()); // 同下
        for (int i = 0; i < n; i++) {
            g[i] = new ArrayList<>();
        }
    }

    // 加一条 x 到 y 的边
    public static void addEdge(int x, int y) {
        g[x].add(y);
    }

    public static void printGraph() {
        for (int x = 0; x < n; x++) {
            System.out.print(x + " --> ");
            for (int y : g[x]) {
                System.out.print("[" + y + "] ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        n = 5;
        init();
        addEdge(0, 1);
        addEdge(0, 4);
        addEdge(1, 4);
        addEdge(2, 1);
        addEdge(2, 3);
        addEdge(3, 2);
        addEdge(4, 3);

        printGraph();

    }
}

运行结果：

2）有权图

public class Code02_createBy_AdjacencyList2 {

    public static int n; //顶点个数

    public static List<int[]>[] g; //邻接表

    // 初始化
    public static void init() {
        g = new ArrayList[n];
        Arrays.setAll(g, i -> new ArrayList<>());
    }

    // 有向图， 加一条 x 到 y 的边，权值为 w
    public static void addEdge1(int x, int y, int w) {
        g[x].add(new int[]{y, w});
    }

    // 无向图，加一条 x 与 y 的边，权值为 w
    public static void addEdge2(int x, int y, int w) {
        g[x].add(new int[]{y, w});
        g[y].add(new int[]{x, w});
    }

    public static void printGraph() {
        for (int x = 0; x < n; x++) {
            System.out.print(x + "--> ");
            for (int[] edge : g[x]) {
                int y = edge[0];
                int w = edge[1];
                System.out.print("[" + y + ", " + w + "] ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        n = 5;
        init();

        addEdge1(0, 1, 8);
        addEdge1(0, 4, 7);
        addEdge1(1, 4, 11);
        addEdge1(2, 1, 12);
        addEdge1(2, 3, 5);
        addEdge1(3, 2, 8);
        addEdge1(4, 3, 9);

        printGraph();
    }

}

运行结果：

结束

有问题欢迎指正，困zzz