数据结构与算法(十五)之图

图简介

当需要表示多对多关系时候就需要图。

图的表示方法

1. 邻接表
   
   由数组+链表组成
2. 邻接矩阵
   

两者的优缺点：

• 邻接矩阵牺牲空间换时间。
• 邻接表相较于邻接矩阵会节省空间，但查询时间是需要遍历链表的。

图的遍历

DFS与BFS

• DFS：深度优先搜索，主要由栈和递归实现。
• BFS：广度优先搜索，主要由队列实现。
  

代码实现

广度优先搜索，主要由队列实现

public class Graph {
    private int[][] graph;//邻接矩阵图
    private boolean[] isVisit;
    private int nodeNum;

    public Graph(int[][] graph, int nodeNum) {
        this.graph = graph;
        this.nodeNum = nodeNum;
    }

    public void DFS() {
        if (graph == null) return;
        Stack<Integer> stack = new Stack<>();
        isVisit = new boolean[nodeNum];
        stack.push(0);
        isVisit[0] = true;
        while (!stack.isEmpty()) {
            int node = stack.pop();
            System.out.print(node + "->");
            for (int i = 0; i < nodeNum; i++) {
                if (graph[node][i] == 1 && !isVisit[i]) {
                    stack.push(i);
                    isVisit[i] = true;
                }
            }
        }
    }

    public void BFS() {
        if (graph == null) return;
        Queue<Integer> queue = new LinkedList<>();
        isVisit = new boolean[nodeNum];
        queue.offer(0);
        isVisit[0] = true;
        while (!queue.isEmpty()) {
            int node = queue.poll();
            System.out.print(node + "->");
            for (int i = 0; i < nodeNum; i++) {
                if (graph[node][i] == 1 && !isVisit[i]) {
                    queue.offer(i);
                    isVisit[i] = true;
                }
            }
        }
    }
}

并查集

一个视频弄懂并查集

并查集的作用

1. 维护无向图的连通性。支持判断两个点是否在同一连通块内。
2. 判断增加一条边是否会产生环：用在求解最小生成树的Kruskal算法里。

最小生成树

在一个图中，可以联通所有节点并且不形成环的树的集合叫做生成树集合，其中，所有权重之和最小的树叫最小生成树。最小生成树的形成有2种算法，Kruskal和Prim算法。

Kruskal算法思路

1. 将所有边按照从小到大排序。
2. 依次弹出边放入图中，如果不会形成环则ok，如果会形成环则放弃这条边。

java实现：

public int kruskal() {
        int res = 0;
        //并查集
        int[] checkAndSet = new int[nodeNum + 1];
        //初始化值为-1
        for (int i = 0; i < nodeNum + 1; i++) {
            checkAndSet[i] = -1;
        }
        while (!q.isEmpty()) {
            Edge e = q.poll();
            int root1 = e.node1;
            int root2 = e.node2;
            while (checkAndSet[root1] != -1) {
                root1 = checkAndSet[root1];
            }
            while (checkAndSet[root2] != -1) {
                root2 = checkAndSet[root2];
            }
            if (root1 != root2) {
                //说明无环
                checkAndSet[root2] = root1;
                res += e.dis;
            }
        }
        return res;
    }

prim算法思路

1. 将图分为2个集合，一个是遍历过的节点集合，另一个是没遍历过的节点集合。
2. 对于遍历过的集合对外找到最小边，将这个节点加入遍历过的节点集合。

public int prim() {
        int res = 0;
        //保存是否遍历过
        boolean[] isVisit = new boolean[nodeNum + 1];
        //优先队列，存储当前已遍历集合对外的权值。
        Queue<Pair> pqueue = new PriorityQueue<>(new Comparator<Pair>() {
            @Override
            public int compare(Pair o1, Pair o2) {
                return o1.dis - o2.dis;
            }
        });
        //将1以及边加入优先队列
        for (int i = 1; i <= nodeNum; i++) {
            if (graph[1][i] != 0) {
                pqueue.offer(new Pair(i, graph[1][i]));
            }
        }
        isVisit[1] = true;
        while (!pqueue.isEmpty()) {
            Pair p = pqueue.poll();
            if (isVisit[p.node]) continue;
            for (int i = 1; i <= nodeNum; i++) {
                if (graph[p.node][i] != 0) {
                    pqueue.offer(new Pair(i, graph[p.node][i]));
                }
            }
            res += p.dis;
            isVisit[p.node] = true;
        }

        return res;
    }