数据结构与算法(六),图

图是一种比线性表和树更复杂的数据结构,在图中,结点之间的关系是任意的,任意两个数据元素之间都可能相关。图是一种多对多的数据结构。

  • 1、基本概念

  • 2、图的存储结构

  • 2.1、邻接矩阵

  • 2.2、邻接表

  • 2.3、十字链表

  • 3、图的遍历

  • 3.1、深度优先遍历

  • 3.2、广度优先遍历

  • 4、最小生成树

  • 4.1、Prim算法

  • 4.2、Kruskal算法

  • 5、最短路径

  • 5.1、Dijkstra算法

1、基本概念

图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成,通常表示为:G(V,E),其中,G表示一个图,V是图G中顶点的集合,E是图G中边的集合。

注意:线性表中可以没有元素,称为空表。树中可以没有结点,叫做空树。但是在图中不允许没有顶点,可以没有边。

基本术语:

  • 无向边:若顶点Vi和Vj之间的边没有方向,称这条边为无向边(Edge),用(Vi,Vj)来表示。

  • 无向图(Undirected graphs):图中任意两个顶点的边都是无向边。

  • 有向边:若从顶点Vi到Vj的边有方向,称这条边为有向边,也称为弧(Arc),用<Vi, Vj>来表示,其中Vi称为弧尾(Tail),Vj称为弧头(Head)。

  • 有向图(Directed graphs):图中任意两个顶点的边都是有向边。

  • 简单图:不存在自环(顶点到其自身的边)和重边(完全相同的边)的图

  • 无向完全图:无向图中,任意两个顶点之间都存在边。

  • 有向完全图:有向图中,任意两个顶点之间都存在方向相反的两条弧。

  • 稀疏图;有很少条边或弧的图称为稀疏图,反之称为稠密图。

  • 权(Weight):表示从图中一个顶点到另一个顶点的距离或耗费。

  • 网:带有权重的图

  • 度:与特定顶点相连接的边数;

  • 出度、入度:有向图中的概念,出度表示以此顶点为起点的边的数目,入度表示以此顶点为终点的边的数目;

  • 环:第一个顶点和最后一个顶点相同的路径;

  • 简单环:除去第一个顶点和最后一个顶点后没有重复顶点的环;

  • 连通图:任意两个顶点都相互连通的图;

  • 极大连通子图:包含竟可能多的顶点(必须是连通的),即找不到另外一个顶点,使得此顶点能够连接到此极大连通子图的任意一个顶点;

  • 连通分量:极大连通子图的数量;

  • 强连通图:此为有向图的概念,表示任意两个顶点a,b,使得a能够连接到b,b也能连接到a 的图;

  • 生成树:n个顶点,n-1条边,并且保证n个顶点相互连通(不存在环);

  • 最小生成树:此生成树的边的权重之和是所有生成树中最小的;

  • AOV网(
    Activity On Vertex Network ):在有向图中若以顶点表示活动,有向边表示活动之间的先后关系

  • AOE网(
    Activity On Edge Network):在带权有向图中若以顶点表示事件,有向边表示活动,边上的权值表示该活动持续的时间

2、图的存储结构

由于图的结构比较复杂,任意两个顶点之间都可能存在关系,因此用简单的顺序存储来表示图是不可能,而若使用多重链表的方式(即一个数据域多个指针域的结点来表示),这将会出现严重的空间浪费或操作不便。这里总结一下常用的表示图的方法:

2.1、邻接矩阵

图的邻接矩阵(Adjacency Matrix)存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息,一个二维数组(称邻接矩阵)存储图中的边或弧的信息。

无向图由于边不区分方向,所以其邻接矩阵是一个对称矩阵。邻接矩阵中的0表示边不存在,主对角线全为0表示图中不存在自环。

带权有向图的邻接矩阵:

在带权有向图的邻接矩阵中,数字表示权值weight,「无穷」表示弧不存在。由于权值可能为0,所以不能像在无向图的邻接矩阵中那样使用0来表示弧不存在。

代码:

/**
 * 有向图的邻接矩阵实现
 */
public class Digraph {
    private int vertexsNum;
    private int edgesNum;
    private int[][] arc;

    public Digraph(int[][] data, int vertexsNum) {
        this.vertexsNum = vertexsNum;
        this.edgesNum = data.length;
        arc = new int[vertexsNum][vertexsNum];
        for (int i = 0; i < vertexsNum; i++) {
            for (int j = 0; j < vertexsNum; j++) {
                arc[i][j] = Integer.MAX_VALUE;
            }
        }
        
        for (int i = 0; i < data.length; i++) {
            int tail = data[i][0];
            int head = data[i][1];
            arc[tail][head] = 1;
        }
    }
    
    //用于测试,返回一个顶点的邻接点
    public Iterable<Integer> adj(int vertex) {
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < vertexsNum; i++) {
            if (arc[vertex][i] != Integer.MAX_VALUE)
                set.add(i);
        }
        return set;
    }
    
    public static void main(String[] args) {
        int[][] data = {
                {0,3},
                {1,0},
                {1,2},
                {2,0},
                {2,1},
        };
        Digraph wd = new Digraph(data,4);
        for(int i :wd.adj(1)) {
            System.out.println(i);
        }   
    }
}

优缺点:

  • 优点:结构简单,操作方便
  • 缺点:对于稀疏图,这种实现方式将浪费大量的空间。

2.2、邻接表

邻接表是一种将数组与链表相结合的存储方法。其具体实现为:将图中顶点用一个一维数组存储,每个顶点Vi的所有邻接点用一个单链表来存储。这种方式和树结构中孩子表示法一样。

对于有向图其邻接表结构如下:

有向图的邻接表是以顶点为弧尾来存储边表的,这样很容易求一个顶点的出度(顶点对应单链表的长度),但若求一个顶点的入度,则需遍历整个图才行。这时可以建立一个有向图的逆邻接表即对每个顶点v都建立一个弧头尾v的单链表。如上图所示。

代码:

/**
 * 有向图的邻接表实现
 *
 */
public class AdjListDigraph {
    
    private class EdgeNode {
        int index;
        EdgeNode next;
        EdgeNode(int index, EdgeNode next){
            this.index = index;
            this.next = next;
        }
    }
    
    private class VertexNode {
        int id;
        EdgeNode headNode;
    }
    
    private VertexNode[] vertexs;
    private int vertexsNum;
    private int edgesNum;
    
    public AdjListDigraph(int[][] data, int vertexsNum) {
        this.vertexsNum = vertexsNum;
        this.edgesNum = data.length;
        vertexs = new VertexNode[vertexsNum];
        for (int i = 0; i < vertexs.length; i++) {
            vertexs[i] = new VertexNode();
            vertexs[i].id = i;        //
        }
        
        for (int i = 0; i < data.length; i++) {
            int index = data[i][1];
            EdgeNode next = vertexs[data[i][0]].headNode;
            EdgeNode eNode = new EdgeNode(index,next);
            vertexs[data[i][0]].headNode = eNode; //头插法
        }
        
    }
    
    //用于测试,返回一个顶点的邻接点
    public Iterable<Integer> adj(int index) {
        Set<Integer> set = new HashSet<>();
        EdgeNode current = vertexs[index].headNode;
        while(current != null) {
            VertexNode node = vertexs[current.index];
            set.add(node.id);
            current = current.next;
        }
        return set;
    }
    
    public static void main(String[] args) {
        int[][] data = {
                {0,3},
                {1,0},
                {1,2},
                {2,0},
                {2,1},
        };
        AdjListDigraph ald = new AdjListDigraph(data,4);
        for(int i :ald.adj(1)) {
            System.out.println(i);
        }   
    }
}

本算法的时间复杂度为 O(N + E),其中N、E分别为顶点数和边数,邻接表实现比较适合表示稀疏图。

2.3、十字链表

十字链表(Orthogonal List)是将邻接表和逆邻接表相结合的存储方法,它解决了邻接表(或逆邻接表)的缺陷,即求入度(或出度)时必须遍历整个图。

十字链表的结构如下:

图中:

  • firstIn表示入边表(即是逆邻接表中的单链表)头指针,firstOut表示出边表(即是邻接表中的单链表)头指针,data表示顶点数据。
  • tailVex表示边的起点在顶点数组中的下标,tailNext值出边表指针域,指向起点相同的下一条边。
  • headVex表示边的终点在顶点数组中的下标,headNext指入边表指针域,指向终点相同的下一条边。

代码实现:

/**
 * 有向图的十字链表实现
 *
 */
public class OrthogonalList {
    
    private class EdgeNode {
        int tailVex;
        int headVex;
        EdgeNode headNext;
        EdgeNode tailNext;
        
        public EdgeNode(int tailVex, int headVex, EdgeNode headNext, EdgeNode tailNext) {
            super();
            this.tailVex = tailVex;
            this.headVex = headVex;
            this.headNext = headNext;
            this.tailNext = tailNext;
        }
        
    }
    
    private class VertexNode {
        int data;
        EdgeNode firstIn;
        EdgeNode firstOut;
    }
    
    private VertexNode[] vertexs;
    private int vertexsNum;
    private int edgesNum;
    
    public OrthogonalList(int[][] data, int vertexsNum) {
        this.vertexsNum = vertexsNum;
        this.edgesNum = data.length;
        vertexs = new VertexNode[vertexsNum];
        for (int i = 0; i < vertexs.length; i++) {
            vertexs[i] = new VertexNode();
            vertexs[i].data = i;        //
        }
        
        //关键
        for (int i = 0; i < data.length; i++) {
            int tail = data[i][0];
            int head = data[i][1];
            EdgeNode out = vertexs[tail].firstOut;
            EdgeNode in = vertexs[head].firstIn;
            EdgeNode eNode = new EdgeNode(tail,head,in,out);
            vertexs[tail].firstOut = eNode;
            vertexs[head].firstIn = eNode;
        }
        
    }
    
    //返回一个顶点的出度
    public int outDegree(int index) {
        int result = 0;
        EdgeNode current = vertexs[index].firstOut;
        while(current != null) {
            current = current.tailNext;
            result++;
        }
        return result;
    }
    
    //返回一个顶点的入度
    public int inDegree(int index) {
        int result = 0;
        EdgeNode current = vertexs[index].firstIn;
        while(current != null) {
            current = current.headNext;
            result++;
        }
        return result;
    }
    
    public static void main(String[] args) {
        int[][] data = {
                {0,3},
                {1,0},
                {1,2},
                {2,0},
                {2,1},
        };
        OrthogonalList orth = new OrthogonalList(data,4);
        System.out.println("顶点1的出度为" + orth.outDegree(1));
        System.out.println("顶点1的入度为" + orth.inDegree(1));
            
    }
}

十字链表创建图算法的时间复杂度和邻接表相同都为O(N + E)。在有图的应用中推荐使用。

3、图的遍历

从图的某个顶点出发,遍历图中其余顶点,且使每个顶点仅被访问一次,这个过程叫做图的遍历(Traversing Graph)。对于图的遍历通常有两种方法:深度优先遍历和广度优先遍历。

3.1、深度优先遍历

深度优先遍历(Depth First Search,简称DFS),也成为深度优先搜索。

遍历思想:基本思想:首先从图中某个顶点v0出发,访问此顶点,然后依次从v相邻的顶点出发深度优先遍历,直至图中所有与v路径相通的顶点都被访问了;若此时尚有顶点未被访问,则从中选一个顶点作为起始点,重复上述过程,直到所有的顶点都被访问。

深度优先遍历用递归实现比较简单,只需用一个递归方法来遍历所有顶点,在访问某一个顶点时:

  • 将它标为已访问
  • 递归的访问它的所有未被标记过的邻接点

深度优先遍历的过程:

代码如下:

public class DFSTraverse {
    
    private boolean[] visited;
    
    //从顶点index开始遍历
    public DFSTraverse(Digraph graph, int index) {
        visited = new boolean[graph.getVertexsNum()];
        dfs(graph,index);
    }

    private void dfs(Digraph graph, int index) {
        visited[index] = true;
        for(int i : graph.adj(index)) {
            if(!visited[i])
                dfs(graph,i);   
        }
    }
}

3.2、广度优先遍历

广度优先遍历(Breadth First Search,简称BFS),又称为广度优先搜索

遍历思想:首先,从图的某个顶点v0出发,访问了v0之后,依次访问与v0相邻的未被访问的顶点,然后分别从这些顶点出发,广度优先遍历,直至所有的顶点都被访问完。

广度优先遍历的过程:

代码:

public class BFSTraverse {
    
    private boolean[] visited;
    
    public BFSTraverse(AdjListDigraph graph, int index) {
        visited = new boolean[graph.getVertexsNum()];
        bfs(graph,index);
    }

    private void bfs(AdjListDigraph graph, int index) {
        //在JSE中LinkedList实现了Queue接口
        Queue<Integer> queue = new LinkedList<>();
        visited[index] = true;
        queue.add(index);
        while(!queue.isEmpty()) {
            int vertex = queue.poll();
            for(int i : graph.adj(vertex)) {
                if(!visited[i]) {
                    visited[i] = true;
                    queue.offer(i);
                }
            }
        }
    }
}

4、最小生成树

图的生成树是它的一棵含有所有顶点的无环连通子图。一棵加权图的最小生成树(MST)是它的一棵权值(所有边的权值之和)最小的生成树。

计算最小生成树可能遇到的情况:

  • 非连通的无向图,不存在最小生成树
  • 权重不一定和距离成正比
  • 权重可能是0或负数
  • 若存在相等的权重,那么最小生成树可能不唯一

图的切分是将图的所有顶点分为两个非空且不重叠的两个集合。横切边是一条连接两个属于不同集合的顶点的边。

切分定理:在一幅加权图中,给定任意的切分,它的横切边中的权重最小者必然属于图的最小生成树。

切分定理是解决最小生成树问题的所有算法的基础。这些算法都是贪心算法。

切分定理

首先先构造一个带权的无向图,其代码如下:

//定义边
public class Edge implements Comparable<Edge>{
    private final int ver1;
    private final int ver2;
    private final Integer weight;
    public Edge(int ver1, int ver2, int weight) {
        super();
        this.ver1 = ver1;
        this.ver2 = ver2;
        this.weight = weight;
    }
    //返回一个顶点
    public int either() {
        return ver1;
    }
    //返回另一个顶点
    public int other(int vertex) {
        if (vertex == ver1)
            return ver2;
        else if(vertex == ver2)
            return ver1;
        else 
            throw new RuntimeException("边不一致");
    }
    @Override
    public int compareTo(Edge e) {
        return this.weight.compareTo(e.weight);
    }
    
    public Integer getWeight() {
        return weight;
    }
    @Override
    public String toString() {
        return "Edge [" + ver1 + "," + ver2 +"]";
    }
}

/**
 * 带权无向图的实现
 */
public class WeightedGraph {
    private final int vertexsNum;
    private final int edgesNum;
    private List<Edge>[] adj;
    
    public WeightedGraph(int[][] data, int vertexsNum) {
        this.vertexsNum = vertexsNum;
        this.edgesNum = data.length;
        adj  = (List<Edge>[]) new ArrayList[vertexsNum];
        for(int i=0; i<vertexsNum; i++) {
            adj[i] = new ArrayList<>();
        }

        for (int i = 0; i < data.length; i++) {
            Edge edge = new Edge(data[i][0],data[i][1],data[i][2]);
            int v = edge.either();
            adj[v].add(edge);
            adj[edge.other(v)].add(edge);
        }
    }
    
    public Iterable<Edge> adj(int vertex) {
        return adj[vertex];
    }

    public int getVertexsNum() {
        return vertexsNum;
    }

    public int getEdgesNum() {
        return edgesNum;
    }
    
    public Iterable<Edge> getEdges() {
        List<Edge> edges = new ArrayList<>();
        for(int i=0; i<vertexsNum; i++) {
            for(Edge e : adj[i]) {
                if(i > e.other(i)) { //无向图,防止将一条边加入两次
                    edges.add(e);
                }
            }
        }
        return edges;
    }
}

4.1、Prim算法

每次将权值最小的横切边加入生成树中

1)、Prim算法的延迟实现

实现过程如下图:

从顶点0开始,首先将顶点0加入到树中(标记),顶点0和其它点的横切边(这里即为顶点0的邻接边)加入优先队列,将权值最小的横切边出队,加入生成树中。此时相当于也向树中添加了一个顶点2,接着将集合(顶点1,2组成)和另一个集合(除1,2的顶点组成)间的横切边加入到优先队列中,如此这般,直到队列为空。

注意:若横切边中另一个顶点在树中,则此边失效。

代码如下:

public class LazyPrimMST {
    private boolean[] visited; //标记顶点
    private LinkedQueue<Edge> mst; //存储最小生成树的边
    private MinPQ<Edge> pq; //优先队列,权值越最小优先级越高
    
    public LazyPrimMST(WeightedGraph wg) {
        visited = new boolean[wg.getVertexsNum()];
        mst = new LinkedQueue<Edge>();
        pq = new MinPQ<>(wg.getVertexsNum());
        
        visit(wg, 0); //从0点开始
        while(!pq.isEmpty()) {
            Edge e = pq.deQueue();
            int ver1 = e.either();
            int ver2 = e.other(ver1);
            if(visited[ver1] && visited[ver2]) {
                continue; //边失效
            }
            mst.enQueue(e);
            if(!visited[ver1])
                visit(wg, ver1);
            if(!visited[ver2])
                visit(wg, ver2);
        }
    }

    private void visit(WeightedGraph wg, int ver) {
        visited[ver] = true; //标记顶点
        for(Edge e : wg.adj(ver)) {
            if(!visited[e.other(ver)])
                pq.enQueue(e);
        }
    }
    
    public Iterable<Edge> getMST() {
        return mst;
    }
    
    public static void main(String[] args) {
        int[][] data = {
                {0, 2, 2},
                {0, 1, 4},
                {0, 5, 5},
                {1, 2, 3},
                {1, 5, 11},
                {1, 3, 7},
                {2, 3, 8},
                {2, 4, 10},
                {3, 5, 6},
                {3, 4, 1},
                {4, 5, 9}
        };
        WeightedGraph wg = new WeightedGraph(data,6);
        LazyPrimMST lpm = new LazyPrimMST(wg);
        for(Edge e : lpm.getMST()) {
            System.out.println(e);
        }
    }
}

其中,LinkedQueue类的代码在《数据结构与算法(三),栈与队列》中;而MinPQ类的代码与《数据结构与算法(五),优先队列》中MaxPQ类的代码几乎一样,只需将方法less中的小于号改为大于号即可。这里就不在给出代码了

此方法的时间复杂度为 O(ElogE),空间复杂度为 O(E)。其中,V为顶点个数,E为边数

2)、Prim算法即时实现

基于Prim算法的延迟实现,我们可以在优先队列中只保存每个非树顶点V的一条边(即它与树中的顶点连接起来的权重最小的那条边),因为其他权重较大的边迟早都会失效。

实现过程如下图:

代码实现:

/**
 * prim的即时实现
 */
public class PrimMST {
    private Edge[] edgeTo; //点离生成树最近的边
    private int[] distTo; //点到生成树的距离
    private boolean[] visited;
    private IndexMinPQ<Integer> pq; //索引优先队列,关联顶点与distTo
    
    public PrimMST(WeightedGraph wg) {
        //初始化
        edgeTo = new Edge[wg.getVertexsNum()];
        distTo = new int[wg.getVertexsNum()];
        visited = new boolean[wg.getVertexsNum()];
        for(int i=0; i<wg.getVertexsNum(); i++) {
            distTo[i] = Integer.MAX_VALUE;
        }
        pq = new IndexMinPQ<>(wg.getVertexsNum());
        distTo[0] = 0;
        pq.insert(0, 0);
        
        while(!pq.isEmpty()) {
            visit(wg, pq.delMin());
        }
    }

    private void visit(WeightedGraph wg, int ver) {
        visited[ver] = true;
        for(Edge e : wg.adj(ver)) {
            int vertex = e.other(ver); //边的另一个点
            if(visited[vertex])
                continue;
            if(e.getWeight() < distTo[vertex]) {
                edgeTo[vertex] = e; //被覆盖的边失效
                distTo[vertex] = e.getWeight();
                if(pq.contains(vertex)) {
                    pq.change(vertex, distTo[vertex]); 
                }else {
                    pq.insert(vertex, distTo[vertex]);
                }
            }
        }
    }
    
    public Iterable<Edge> getMST() {
        return Arrays.asList(edgeTo);
    }
}

此方法的时间复杂度为 O(ElogV),空间复杂度为 O(V)。其中,V为顶点个数,E为边数。

可以看出Prim算法的即时实现比延迟实现明显要快,特别是对于稠密矩阵(E>>>V)的情况。

4.2、Kruskal算法

Kruskal算法的思想是按照边的权重顺序来生成最小生成树,首先将图中所有边加入优先队列,将权重最小的边出队加入最小生成树,保证加入的边不与已经加入的边形成环,直到树中有V-1到边为止。

实现过程如下图:

/**
 * Kruskal算法的实现
 */
public class KruskalMST {
    private List<Edge> mst; //存储最小生成树的边
    private MinPQ<Edge> pq; //优先队列
    private int[] parent; //用来判断边与边是否形成回路
    
    public KruskalMST(WeightedGraph wg) {
        mst = new ArrayList<Edge>();
        pq = new MinPQ<>(wg.getEdgesNum());
        parent = new int[wg.getVertexsNum()];
        for(Edge e : wg.getEdges()) {
            pq.enQueue(e);
        }
        //最小生成树的边最多为V-1个
        while(!pq.isEmpty() && mst.size() < wg.getVertexsNum() - 1) {
            Edge e = pq.deQueue();
            int v = e.either();
            int n = find(parent, v);
            int m = find(parent, e.other(v));
            if(n != m) { //表示此边没有与生成树形成环路
                parent[n] = m;
                mst.add(e);
            }
        }
    }
    
    //查找连接树的尾部下标
    private int find(int[] data, int v) {
        while(parent[v] > 0) {
            v = parent[v];
        }
        return v;
    }
    
    public Iterable<Edge> getMST() {
        return mst;
    } 
}

Kruskal算法的时间复杂度最坏情况下为O(ElogE)。空间复杂度为O(E)。

对比Prim算法和Kruskal算法,Kruskal算法主要根据边来生成树,边数少时效率比较高,适合稀疏图;而Prim算法对边数多的稠密图效果更好一些。

5、最短路径

最短路径指两顶点之间经过的边上权值之和最少的路径,并且称路径上的第一个顶点为源点,最后一个顶点为终点。

为了操作方便,首先使用面向对象的方法,来实现一个加权的有向图,其代码如下:

/**
 * 有向边
 */
public class Edge{
    private final int from;
    private final int to;
    private final int weight;
    public Edge(int from, int to, int weight) {
        super();
        this.from = from;
        this.to = to;
        this.weight = weight;
    }
    
    public int getFrom() {
        return from;
    }
    
    public int getTo() {
        return to;
    }
    
    public int getWeight() {
        return weight;
    }
}

//带权有向图的实现
public class WeightedDigraph {
    private final int vertexsNum;
    private final int edgesNum;
    private List<Edge>[] adj; //邻接表
    
    public WeightedDigraph(int[][] data, int vertexsNum) {
        this.vertexsNum = vertexsNum;
        this.edgesNum = data.length;
        adj  = (List<Edge>[]) new ArrayList[vertexsNum];
        for(int i=0; i<vertexsNum; i++) {
            adj[i] = new ArrayList<>();
        }

        for (int i = 0; i < data.length; i++) {
            Edge edge = new Edge(data[i][0],data[i][1],data[i][2]);
            int v = edge.getFrom();
            adj[v].add(edge);
        }
    }
    
    public Iterable<Edge> adj(int vertex) {
        return adj[vertex];
    }

    public int getVertexsNum() {
        return vertexsNum;
    }

    public int getEdgesNum() {
        return edgesNum;
    }
    
    //有向图中所有的边
    public Iterable<Edge> getEdges() {
        List<Edge> edges = new ArrayList<>();
        for(List<Edge> list : adj) {
            for(Edge e : list) {
                edges.add(e);
            }
        }
        return edges;
    }
}

顶点到源点s的最短路径,我们使用一个用顶点索引的Edge数组(edgeTo[])来存储,使用数组distTo[]来存储最短路径树(包含了源点S到所有可达顶点的最短路径)。

边的松弛操作:

边的松弛过程如下图:

松弛边【1,4】就是检查顶点0到4的最短路径是否是先从顶点0到1,然后在由顶点1到4。如果是则【0,4】边失效,将【1,4】加入最短路径树。

代码:

private void relax(WeightedDigraph wd,Edge e) {
    int v = e.getFrom();
    int w = e.getTo();
    if(distTo[w] > distTo[v] + e.getWeight()) {
        distTo[w] = distTo[v] + e.getWeight();
        edgeTo[w] = e;
    }
}

顶点的松弛操作:

顶点的松弛就是松弛顶点的所有邻接边,这里就不给出过程了,实现代码在Dijkstra实现中。

5.1、Dijkstra算法

算的的实现过程:

Dijkstra算法的代码实现:

//Dijkstra算法的实现
public class Dijkstra {
    private Edge[] edgeTo; //最短路径树
    private int[] distTo; //存储每个顶点到源点的距离
    //索引优先队列,建立distTo和顶点索引,distTo越小,优先级越高
    private IndexMinPQ<Integer> pq; 
    
    public Dijkstra(WeightedDigraph wd, int s) {
        edgeTo = new Edge[wd.getVertexsNum()];
        distTo = new int[wd.getVertexsNum()];
        pq = new IndexMinPQ<>(wd.getVertexsNum());
        for(int i=0; i<wd.getVertexsNum(); i++) {
            distTo[i] = Integer.MAX_VALUE;
        }
        distTo[s] = 0; //源点s的distTo为0
        pq.insert(s, 0);
        while(pq.isEmpty()) {
            relax(wd, pq.delMin());
        }
    }
    
    //顶点的松弛
    private void relax(WeightedDigraph wd, int ver) {
        for(Edge e : wd.adj(ver)) {
            int v = e.getTo();
            if(distTo[v] > distTo[ver] + e.getWeight()) {
                distTo[v] = distTo[ver] + e.getWeight();
                edgeTo[v] = e;
                if(pq.contains(v)) {
                    pq.change(v, distTo[v]);
                }else {
                    pq.insert(v, distTo[v]);
                }
            }
        }
    }
}

Dijkstra算法的局限性:图中边的权重必须为正,但可以是有环图。时间复杂度为O(ElogV),空间复杂度O(V)。


这篇文章写了好久,陆陆续续差不多快10天了,至今还有以下内容没有总结:

  • 图的邻接多重表
  • 图的边集数组实现
  • 最短路径的Floyd算法
  • 拓扑排序
  • union-find算法
  • 无环加权有向图的最短路径算法
  • 关键路径
  • 计算无向图中连通分量的Kosaraju算法
  • 有向图中含必经点的最短路径问题
  • TSP问题
  • 还有A*算法

图的知识实在是太多了,就先总结到这里吧,有时间在写。

推荐阅读更多精彩内容