利用enum实现图

//com.insanus.Node.java
package com.insanus;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Set;

public enum Node {
    A, B, C, D;
    //存放结点
    private boolean visit;
    private Set<Node> data;
    Node() {
        data = new HashSet<>();
        visit = false;
    }
    public Node[] getData() {
        return data.toArray(new Node[0]);
    }
    public boolean getVisit() {
        return visit;
    }

    public void changeVisit() {
        visit = !visit;
    }
    public static void changeFalseVisit() {
        for (Node i : Node.values()) {
            if(i.getVisit() == true) {
                i.changeVisit();
            }
        }
    }

    public void add(Node i) {
        data.add(i);
    }
    //有向图
    public static void relation(Node n, Node m) {
        n.add(m);
        m.add(n);
    }

    public static int getNodeSize() {
        return Node.values().length;
    }

    public static void initMap(int[][] i) {
        Node[] data = Node.values();
        for (int x = 0; x < i.length; x ++) {
            for (int m = 0; m < i.length; m ++) {
                if(i[x][m] == 1) {
                    relation(data[x], data[m]);
                }
            }
        }
    }

    public static void DFS(Node i) {
        System.out.println(i);
        i.changeVisit();
        for (Node n: i.getData()) {
            if (n.getVisit())
                continue;
            DFS(n);
        }
    }
    public static void BFS(Node i) {
        LinkedList<Node> data = new LinkedList<>();
        Node n;
        data.addLast(i);
        i.changeVisit();
        while(!data.isEmpty()) {
            System.out.println(n = data.remove(0));
            for (Node a: n.getData()) {
                if (!a.getVisit()) {
                    data.addLast(a);
                    a.changeVisit();
                }
            }
        }
    }
    public static void main(String[] args) {
        int [][] map = {
                {1, 1, 1, 0},
                {1, 1, 0, 1},
                {1, 0, 1, 1},
                {0, 1, 1, 1}
        };
        initMap(map);
        Node root = Node.A;
        BFS(root);
        changeFalseVisit();
        System.out.println("-----------------");
        DFS(root);
    }
}/* Output:
A
B
C
D
-----------------
A
B
D
C
*///:~

实现了用enum实现无向图，可以通过输入一个邻接矩阵来建图。