图建模

import java.util.List;

/**
 *
 * @param <V> 参数V是一个泛型，表示图中顶点
 *
 */
public interface Graph<V> {
    /**
     *
     * @return 返回值是图中的顶点个数
     */
    public int getSize();

    /**
     *
     * @return 返回值是图中所有的顶点对象
     */
    public List<V> getVertices();

    /**
     *
     * @param index 表示要获取的顶点的索引
     * @return 返回指定下标的顶点对象
     */
    public V getVertex(int index);

    /**
     *
     * @param v 参数v表示要获取下标的顶点对象
     * @return 返回值是指定下标的顶点的索引
     */

    public int getIndex(V v);

    /**
     *
     * @param index
     * @return  返回指定下标的顶点的邻居
     */

    public List<Integer> getNeighbors(int index);

    /**
     *
     * @param v
     * @return  返回指定顶点的度
     */
    public int getDegree(int v);

    /**
     * 打印所有的边
     */

    public void printEdges();

    /**
     * 清楚图
     */
    public void clear();

    /**
     * 向图中添加顶点vertex
     * @param vertex
     */
    public boolean addVertex(V vertex);

    /**
     * 向图中添加边<u,v>
     * @param u
     * @param v
     */
    public boolean addEdge(int u,int v);
}

import java.util.ArrayList;
import java.util.List;

public abstract class AbstractGraph<V> implements Graph<V> {

    List<V> vertices = new ArrayList<>();
    List<List<Edge>> neighbors = new ArrayList<>();

    public AbstractGraph() {
    }

    /**
     * 由一个顶点数组和边数组构建一个图
     * @param vertices
     * @param edges
     */
    public AbstractGraph(V[] vertices,int[][] edges ) {

        for (V vertex : vertices) {
            addVertex(vertex);
        }
        createAdjacencyLists(edges);
    }

    protected  void createAdjacencyLists(int[][] edges){

        for (int i = 0; i < edges.length; i++) {

            addEdge(edges[i][0],edges[i][1]);
        }
    }

    /**
     * 由一个顶点列表和一个边列表构建图
     * @param edges
     */
    public AbstractGraph(List<V> vertices,List<Edge> edges) {

        for (V vertex : vertices) {
            addVertex(vertex);
        }
        createAdjacencyLists(edges);
    }

    protected  void createAdjacencyLists(List<Edge> edges){

        for (Edge edge : edges) {
            addEdge(edge.getU(),edge.getV());
        }
    }

    @Override
    public int getSize() {
        return vertices.size();
    }

    @Override
    public List getVertices() {
        return vertices;
    }

    @Override
    public V getVertex(int index) {
        return vertices.get(index);
    }

    @Override
    public int getIndex(V v) {
        return vertices.indexOf(v);
    }

    @Override
    public List<Integer> getNeighbors(int index) {

        ArrayList<Integer> res = new ArrayList<>();

        for (Edge edge : neighbors.get(index)) {
            res.add(edge.getV());
        }
        return res;
    }

    @Override
    public int getDegree(int v) {
        return neighbors.get(v).size();
    }

    @Override
    public void printEdges() {

        for (int i = 0; i < neighbors.size(); i++) {

            System.out.println(getVertex(i) + "(" + i + "):" );
            for (Edge edge : neighbors.get(i)) {
                System.out.println("(" + getVertex(edge.getU()) + "," + getVertex(edge.getV()) + ")");
            }
            System.out.println();
        }
    }

    @Override
    public void clear() {
        vertices.clear();
        neighbors.clear();
    }

    @Override
    public boolean addVertex(V vertex) {
        
        if (!vertices.contains(vertex)){
            vertices.add(vertex);
            neighbors.add(new ArrayList<Edge>());
            return true;
        }
        return false;
    }

    @Override
    public boolean addEdge(int u, int v) {
        
        return addEdge(new Edge(u,v));
    }

    private boolean addEdge(Edge edge) {
        
        if (!neighbors.get(edge.getU()).contains(edge)){
            
            neighbors.get(edge.getU()).add(edge);
        }
        return false;
    }
}