Graphs (Java)

 

public class Vertex<T> {

    private int Index;
    private T _data;

    //Constructor
    public Vertex(T data) {
        _data = data;
        Index = -1;
    }

    public int IndexGet() {
        return Index;
    }

    public void IndexSet(int Index) {
        this.Index = Index;
    }

    public T Data() {
        return _data;
    }

    @Override
    public String toString() {
        return "{Vertex} " + Data().toString();
    }

}

import java.util.ArrayList;

public class AdjacencyMatrix {

    private float[][] _matrix;
    private int _size;

    //Constructor
    public AdjacencyMatrix(int size) {
        _matrix = new float[size][size];
        _size = size;
    }

    public int Size() {
        return _size;
    }

    public void AddDirectedEdge(int from, int to, float weight) {
        _matrix[from][to] = weight;
    }

    public void AddUndirectedEdge(int v1, int v2, float weight) {
        _matrix[v1][v2] = weight;
        _matrix[v2][v1] = weight;
    }

    public float GetEdgeWeight(int x, int y) {
        return _matrix[x][y];
    }

    public ArrayList<Integer> GetAdjacencyList(int sourceIndex) {
        ArrayList<Integer> adjacencyList = new ArrayList<Integer>();
        for (int i = 0; i < _size; i++) {
            if (_matrix[sourceIndex][i] != 0) {
                adjacencyList.add(i);
            }
        }
        return adjacencyList;
    }

}

import java.util.ArrayList;

public class Graph<T> {

    private ArrayList<Vertex<T>> _vertices;

    public ArrayList<Vertex<T>> Vertices() {
        return _vertices;
    }

    private AdjacencyMatrix _adjacencyMatrix;

    public Graph(ArrayList<Vertex<T>> vertices) {
        _vertices = vertices;
        for (int i = 0; i < _vertices.size(); i++) {
            _vertices.get(i).IndexSet(i);
        }
        _adjacencyMatrix = new AdjacencyMatrix(_vertices.size());
    }

    public void CreateDirectedEdge(int fromIndex, int toIndex, float weight) {
        if (weight == 0) {
            weight = 1;
        }
        _adjacencyMatrix.AddDirectedEdge(fromIndex, toIndex, weight);
    }

    public void CreateDirectedEdge(Vertex<T> from, Vertex<T> to, float weight) {
        if (weight == 0) {
            weight = 1;
        }
        this.CreateDirectedEdge(from.IndexGet(), to.IndexGet(), weight);
    }

    public void CreateUndirectedEdge(int v1, int v2, float weight) {
        if (weight == 0) {
            weight = 1;
        }
        _adjacencyMatrix.AddUndirectedEdge(v1, v2, weight);
    }

    public void CreateUndirectedEdge(Vertex<T> v1, Vertex<T> v2, float weight) {
        if (weight == 0) {
            weight = 1;
        }
        this.CreateUndirectedEdge(v1.IndexGet(), v2.IndexGet(), weight);
    }

    public ArrayList<Vertex<T>> GetAdjacentVertices(int sourceIndex) {
        ArrayList<Integer> adjacentIndices = _adjacencyMatrix.GetAdjacencyList(sourceIndex);
        ArrayList<Vertex<T>> adjacentVertices = new ArrayList<Vertex<T>>();

        for (int vertexIndex : adjacentIndices) {
            adjacentVertices.add(_vertices.get(vertexIndex));
        }

        return adjacentVertices;
    }

    public ArrayList<Vertex<T>> GetAdjacentVertices(Vertex<T> source) {
        return GetAdjacentVertices(source.IndexGet());
    }

    public float GetEdgeWeight(Vertex<T> v1, Vertex<T> v2) {
        return _adjacencyMatrix.GetEdgeWeight(v1.IndexGet(), v2.IndexGet());
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();

        sb.append("Graph:" + "\n");

        for (Vertex<T> vertex : _vertices) {
            sb.append(vertex.Data().toString());
            sb.append("\t");
            ArrayList<Vertex<T>> adjacentVertices = GetAdjacentVertices(vertex);
            if (adjacentVertices.size() > 0) {
                sb.append("Edge to: ");
                for (Vertex<T> adjVertex : adjacentVertices) {
                    sb.append(adjVertex.Data().toString());
                    sb.append("(w=");
                    sb.append(GetEdgeWeight(vertex, adjVertex));
                    sb.append(") ");
                }
            } else {
                sb.append("No edges");
            }
            sb.append("\n");
        }

        return sb.toString();
    }
}

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {

        Vertex<String> v1 = new Vertex<String>("v1");
        Vertex<String> v2 = new Vertex<String>("v2");
        Vertex<String> v3 = new Vertex<String>("v3");
        Vertex<String> v4 = new Vertex<String>("v4");

        ArrayList<Vertex<String>> vertices = new ArrayList<Vertex<String>>();
        vertices.add(v1);
        vertices.add(v2);
        vertices.add(v3);
        vertices.add(v4);

        Graph<String> graph = new Graph<String>(vertices);

        graph.CreateDirectedEdge(v1, v2, 3);
        graph.CreateDirectedEdge(v4, v1, 1);
        graph.CreateDirectedEdge(v2, v3, 1);
        graph.CreateDirectedEdge(v2, v4, -2);

        System.out.println(graph.toString());
       
    }
}

Graph:
v1 Edge to: v2(w=3.0)
v2 Edge to: v3(w=1.0) v4(w=-2.0)
v3 No edges
v4 Edge to: v1(w=1.0)