图及其简单算法

1.图的基本概念

图是由顶点集合及顶点间的关系组成的一种数据结构：G = (V， E)，其中：顶点集合V = {x|x属于某个数据对象集}是有穷非空集合； E = {(x,y)|x,y属于V}或者E = {<x, y>|x,y属于V && Path(x, y)}是顶点间关系的有穷集合，也叫做边的集合。(x, y)表示x到y的一条双向通路，即(x, y)是无方向的；Path<x, y>表示从x到y的一条单向通路，即Path<x, y>是有方向的。

顶点和边：图中结点称为顶点，第i个顶点记作vi。两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边，图中的第k条边记作ek，ek = (vi，vj)或<vi，vj>。

有向图和无向图：在有向图中，顶点对<x, y>是有序的，顶点对<x，y>称为顶点x到顶点y的一条边(弧)，<x, y>和<y, x>是两条不同的边，比如下图G3和G4为有向图。在无向图中，顶点对(x, y)是无序的，顶点对(x,y)称为顶点x和顶点y相关联的一条边，这条边没有特定方向，(x, y)和(y，x)是同一条边，比如下图G1和G2为无向图。注意：无向边(x, y)等于有向边<x, y>和<y, x>。

完全图：在有n个顶点的无向图中，若有n * (n-1)/2条边，即任意两个顶点之间有且仅有一条边，则称此图为无向完全图，比如上图G1；在n个顶点的有向图中，若有n * (n-1)条边，即任意两个顶点之间有且仅有方向相反的边，则称此图为有向完全图，比如上图G4。

邻接顶点：在无向图中G中，若(u, v)是E(G)中的一条边，则称u和v互为邻接顶点，并称边(u,v)依附于顶点u和v；在有向图G中，若<u, v>是E(G)中的一条边，则称顶点u邻接到v，顶点v邻接自顶点u，并称边<u, v>与顶点u和顶点v相关联。

顶点的度：顶点v的度是指与它相关联的边的条数，记作deg(v)。在有向图中，顶点的度等于该顶点的入度与出度之和，其中顶点v的入度是以v为终点的有向边的条数，记作indev(v);顶点v的出度是以v为起始点的有向边的条数，记作outdev(v)。因此：dev(v) = indev(v) + outdev(v)。注意：对于无向图，顶点的度等于该顶点的入度和出度，即dev(v) = indev(v) = outdev(v)。

路径：在图G = (V， E)中，若从顶点vi出发有一组边使其可到达顶点vj，则称顶点vi到顶点vj的顶点序列为从顶点vi到顶点vj的路径

路径长度：对于不带权的图，一条路径的路径长度是指该路径上的边的条数；对于带权的图，一条路径的路径长度是指该路径上各个边权值的总和。

2.邻接矩阵, 邻接表

(1)邻接矩阵

因为节点与节点之间的关系就是连通与否，即为0或者1，因此邻接矩阵(二维数组)即是：先用一个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系。
1. 无向图的邻接矩阵是对称的，第i行(列)元素之和，就是顶点i的度。有向图的邻接矩阵则不一定是对称的，第i行(列)元素之后就是顶点i 的出(入)度。

2. 如果边带有权值，并且两个节点之间是连通的，上图中的边的关系就用权值代替，如果两个顶点不通，则使用无穷大代替

import java.util.Arrays;

public class Graph {

    int[][] matrix;

    //当前图顶点从0开始
    public Graph(int n) {
        this.matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(matrix[i], 0x3f3f3f3f);
        }
        for (int i = 0; i < n; i++) {
            matrix[i][i] = 0;
        }
    }

    public boolean addEdge(int i, int j, int weight) {
        int n = matrix.length;
        if (i == j || i < 0 || i >= n || j < 0 || j >= n) {
            return false;
        }
        matrix[i][j] = matrix[j][i] = weight;
        return true;
    }

    public void print() {
        int n = matrix.length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Graph graph = new Graph(4);
        graph.addEdge(0, 1, 2);
        graph.addEdge(2, 3, 4);
        graph.addEdge(1, 2, 2);
        graph.addEdge(2, 4, 5);
        graph.print();
    }
}

(2)邻接表

邻接表：使用数组表示顶点的集合，使用链表表示边的关系。

1. 无向图邻接表存储

无向图中同一条边在邻接表中出现了两次。如果想知道顶点vi的度，只需要知道顶点vi边链表集合中结点的数目即可。
 2.有向图存储

有出边表和入边表

与无向图类似,不过每个表都边变成单向了

有向图中每条边在邻接表中只出现一次，与顶点vi对应的邻接表所含结点的个数，就是该顶点的出度，也称出度表，要得到vi顶点的入度，必须检测其他所有顶点对应的边链表，看有多少边顶点的dst取值是i
 

import java.util.ArrayList;

public class Graph {
    static class Node {
        public int src;//起点下标
        public int dest;//终点下标
        public int weight;//权重
        public Node next;

        public Node(int src, int dest, int weight) {
            this.src = src;
            this.dest = dest;
            this.weight = weight;
        }
    }

    private ArrayList<Node> edgeList;
    private char[] arrayV;//存放顶点
    private boolean isDirect;//是否是有向图

    public Graph(int size, boolean isDirect) {
        arrayV = new char[size];
        edgeList = new ArrayList<>(size);
//注意这里，需要每个进行初始化为null
        for (int i = 0; i < size; i++) {
            edgeList.add(null);
        }
        Node node[] = new Node[size];
        this.isDirect = isDirect;
    }

    /**
     * 初始化顶点数组的数据
     *
     * @param array
     */

    public void initArrayV(char[] array) {
        for (int i = 0; i < array.length; i++) {
            arrayV[i] = array[i];
        }
    }

    /**
     * 获取顶点元素在其数组中的下标
     *
     * @param v*@return
     */

    public int getIndexOfV(char v) {
        for (int i = 0; i < arrayV.length; i++) {
            if (arrayV[i] == v) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 给两个顶点的边上，添加权重
     *
     * @param v1
     * @param v2
     * @param weight
     */

    public void addEdge(char v1, char v2, int weight) {
//1、先查找出两个顶点在，顶点数组中的位置
        int src = getIndexOfV(v1);
        int dest = getIndexOfV(v2);
        addEdgeChild(src, dest, weight);
        if (isDirect == false) {
//无向图
            addEdgeChild(dest, src, weight);
        }
    }

    private void addEdgeChild(int src, int dest, int weight) {
        Node cur = edgeList.get(src);
        while (cur != null) {
//说明这个目标顶点已经在当前的链表中
            if (cur.dest == dest) {
                return;
            }
            cur = cur.next;
        }
        //不在的话，重新生成节点，头插法插入
        Node node = new Node(src, dest, weight);
        node.next = edgeList.get(src);
        edgeList.set(src, node);
    }

    /*** 获取顶点的度
     * 顶点v的度是指与它相关联的边的条数
     * @param v
     * @return
     */
    public int getDevOfV(char v) {
//1、现在顶点数组 arrayV 中找到顶点的下标
        int indexV = getIndexOfV(v);
        Node cur = edgeList.get(indexV);
        int count = 0;
//2、如果是无向图，只需要遍历链表的节点个数
        while (cur != null) {
            count++;
            cur = cur.next;
        } //3、如果是有向图，必须检测其他所有顶点对应的边链表，看有多少边顶点的dst取值是i
//有向图也就一张表
        if (isDirect) {
            int dest = indexV;
//遍历顶点数组的每个元素。
            for (int src = 0; src < arrayV.length; src++) {
                if (src == dest) {
                    continue;//跳过当前自己的顶点链表
                } else {
                    Node pCur = edgeList.get(src);
                    while (pCur != null) {
//目的地是当前顶点的，也就是入度
                        if (pCur.dest == dest) {
                            count++;
                        }
                        pCur = pCur.next;
                    }
                }
            }
        }
        return count;
    }

    public void printGraph() {
        for (int i = 0; i < arrayV.length; i++) {
            System.out.print(arrayV[i] + "-> ");
            Node cur = edgeList.get(i);
            while (cur != null) {
                System.out.print(cur.dest + "-> ");
                cur = cur.next;
            }
            System.out.println("null");
        }
    }
}

3.深度优先和广度优先算法

(1) 广度优先算法

一层一层的最近地遍历

 (2)深度优先搜索

一条路走到底, 到了不能走的时候或者所有的遍历完了回头,然后再找到能走的继续去遍历

 以邻接矩阵写的bfs, dfs

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;

public class Graph {

    int[][] matrix;

    //当前图顶点从0开始
    public Graph(int n) {
        this.matrix = new int[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(matrix[i], 0x3f3f3f3f);
        }
        for (int i = 0; i < n; i++) {
            matrix[i][i] = 0;
        }
    }

    public boolean addEdge(int i, int j, int weight) {
        int n = matrix.length;
        if (i == j || i < 0 || i >= n || j < 0 || j >= n) {
            return false;
        }
        matrix[i][j] = matrix[j][i] = weight;
        return true;
    }

    //单源bfs
    public void bfs(int i) {
        int n = matrix.length;
        Queue<Integer> queue = new LinkedList<>();
        boolean[] visited = new boolean[n];//visited数组用来记录遍历过的元素防止重复的访问
        queue.add(i);
        visited[i] = true;
        while (!queue.isEmpty()) {
            int temp = queue.poll();
            System.out.print(temp + "->");
            for (int j = 0; j < n; j++) {
                if (matrix[temp][j] != 0 && matrix[temp][j] != 0x3f3f3f3f && !visited[j]) {
                    //有边且没有被访问过
                    queue.add(j);
                    visited[j] = true;
                }
            }
        }
    }

    public void dfs(int i) {
        int n = matrix.length;
        boolean[] visited = new boolean[n];
        visited[i] = true;
        f(i, visited);
    }

    public void f(int i, boolean[] visited) {
        System.out.print(i + "->");
        int n = matrix.length;
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] != 0 && matrix[i][j] != 0x3f3f3f3f && !visited[j]) {
                //有边且没有被访问过
                visited[j] = true;
                f(j, visited);
            }
        }
    }

    public static void main(String[] args) {
        Graph graph = new Graph(4);
        graph.addEdge(0, 1, 2);
        graph.addEdge(2, 3, 4);
        graph.addEdge(1, 2, 2);
        graph.addEdge(2, 4, 5);
        graph.bfs(0);
        System.out.println();
        graph.dfs(0);
    }
}

运行结果