获取两个图顶点之间的边列表

Question

I have the own data structure for the graph, and I need the implementation method:

List<Edge<T>> getPath(T start, T finish)

Performance not important, I search the simplest and most readable way. But my data structure should support the directed and undirected graph types and I stuck with it.

public class Graph<T> {

    private boolean isDirected = false;

    private Map<Vertex<T>, List<Edge<T>>> graph = new HashMap<>();

    public Graph() {
    }

    public Graph(boolean isDirected) {
        this.isDirected = isDirected;
    }

    public List<Edge<T>> getPath(T start, T finish) {
        if (start.equals(finish)) {
            return new ArrayList<>();
        }

        // TODO here is the method I'm stuck with.    
        if (isDirected) {
            // Call search for directed graph
        } else {
            // Call search for undirected graph
        }
    }

    public void addEdge(T first, T second) {
        final Vertex<T> master = new Vertex<>(first);
        final Vertex<T> slave = new Vertex<>(second);

        final Set<Vertex<T>> vertices = graph.keySet();
        if (!vertices.contains(master) || !vertices.contains(slave)) {
            throw new IllegalArgumentException();
        }

        graph.get(master).add(new Edge<>(master, slave));

        if (!isDirected) {
            graph.get(slave).add(new Edge<>(slave, master));
        }
    }

    public void addVertex(T value) {
        final List<Edge<T>> result = graph.putIfAbsent(new Vertex<>(value), new ArrayList<>());
        if (result != null) {
            throw new IllegalArgumentException();
        }
    }
}

This Vertex and Edge class:

@Data
@AllArgsConstructor
@EqualsAndHashCode
public class Vertex<T> {
    private T value;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Edge<T> {
    private Vertex<T> first;
    private Vertex<T> second;
}

I will be very grateful for Your help.

Answer 1

It is not totally clear what kind of path you want to find. The shortest path, any path,...?

If you want to find the shortest path, A* is a really simple algorithm to implement. The pseudo code can be found here . A* is a best-first search algorithm for a weighted graph (Eg the distance of an edge or another kind of cost to travel on the edge like time). The algorithm uses a heuristic function to select the next node/vertex to evaluate. A* basically repeats the following steps:

• Select a next node/vertex which has not already been visited. The selection is made using the heuristic function
• If this new node equals the goal position, return the shortest path found
• Evaluate all paths currently known and select the one with the lowest cost

I could also provide a Java code snippet (based on the pseudo code) if it's necessary. Be aware that the pseudo code in the end constructs the shortest path backwards (from goal to start).

You are also using a generic for your graph. Both your Vertext and Edge class use this generic. Let's assume that this generic T is a double . In your code this means that your Vertex is only a one-dimensional double . This does not make sense when you want to represent a graph of 2D or 3D points.

Is it even really necessary to use this generic? Wouldn't it be sufficient to simply support vertices which consists of floats, doubles or integers? Using a generic type or more abstract class (like Number ) might give some problems when you for example want to compute the distance between vertices.