图论算法——无向图的邻接链表实现

引言

有关图的概念可参考博文数据结构之图的概述

比如有个这样的无向图（看起来很像二叉树吧，其实二叉树是一种特殊的图），通过邻接链表表示如下：

我们通过索引表示顶点，索引指向的为一个链表（表示该顶点相邻的所有顶点，比如顶点2相邻的顶点为：0,1,3）。因为是无向图，若增加0-2边，会在0对应的链表中增加2,相应地也会在2对应的链表中增加0。

无向图的邻接集实现

package com.algorithms.graph;

import java.util.HashSet;
import java.util.Set;

/**
 * 无向图
 *
 * 使用0到V-1来表示一个含有V个顶点的图中的各个顶点。
 *
 *
 * @author yjw
 * @date 2019/5/15/015
 */
@SuppressWarnings("unchecked")
public class Graph {
    /**
     * 顶点数
     */
    private int vertexNum;
    /**
     * 边数
     */
    private int edgeNum;

    /**
     * 邻接集：不允许存在平行边
     */
    private Set<Integer>[] adj;

    public Graph(int v) {
        this.vertexNum = v;
        this.edgeNum = 0;
        adj = (Set<Integer>[]) new HashSet[vertexNum];
        /**
         * 代表顶点0到v-1
         */
        for (int i = 0; i < v; i++) {
            adj[i] = new HashSet<>();
        }
    }


    public int vertexNum() {
        return vertexNum;
    }

    public int edgeNum() {
        return edgeNum;
    }

    /**
     * 增加v<->w的边
     * @param v
     * @param w
     */
    public void addEdge(int v,int w) {
        /**
         * 两个端点都加就是无向图了
         */
        if (adj[v].add(w) && adj[w].add(v)) {
            edgeNum++;
        }
    }
    
    /**
     * 增加边的快速方法
     * @param start 起始节点
     * @param ends 结束节点数组
     */
    public void addDiEdges(int start,int ... ends) {
        for (int w : ends) {
            addEdge(start,w);
        }
    }

    public void addEdge(int ... edges) {
        if (edges.length % 2 != 0) {
            throw new IllegalStateException("顶点数必须为2的整数倍");
        }
        for (int i = 0; i < edges.length -1; i+=2) {
            addEdge(edges[i],edges[i+1]);
        }
    }

    /**
     * 计算v的度
     * @param v
     * @return
     */
    public int degree(int v) {
        int degree = 0;
        for (int w : adj(v)) {
            degree++;
        }
        return degree;
    }



    /**
     * 返回由v出发指向的顶点集合
     * @param v
     * @return
     */
    public Iterable<Integer> adj(int v) {
        return adj[v];
    }

    @Override
    public String toString() {
        StringBuilder s = new StringBuilder("(" + vertexNum + " vertices, " + edgeNum + " edges)\n");
        for (int v = 0; v < vertexNum; v++) {
            s.append(v).append(": ");
            for (int w: this.adj(v)) {
                s.append(w).append(" ");
            }
            s.append("\n");
        }
        return s.toString();
    }

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

实例化无向图：

我们可通过该方法很方便的构造前面结构的图结构。
g.addEdge(0,2,2,1,2,3,3,4,3,5);

打印如下：

(6 vertices, 5 edges)
0: 2 
1: 2 
2: 0 1 3 
3: 2 4 5 
4: 3 
5: 3