用Java实现最短路径算法的数据结构

Question

I have been doing some indoor navigation stuffs and need to find the shortest path between two specific nodes. By doing some search found that A* algorithm is more efficient than dijkstra's algorithm. But I have no ideas what to do with my raw data which are:

1. node information: containing node IDs and x, y coordinates, totally three numbers. for example, {node id = 1, x = 0, y = 0}, {node id = 2, x = 1, y = 1}
2. path information: containing a set of node IDs as intermediates to the path. for example, path = {1, 2, 3, 4}

As you can see, these information don't have "distance" values which are used as "weight" in many shortest path algorithms, this means that I have to compute distance between two adjacent nodes before implement any path finding algorithm.

This can be just overwhelming to me not have much coding experience. Can someone help me from the basic concept on how to create a data structure storing node information and path information and further reference it by node id.

Answer 1

This is somehow opinion-based, and depends on the way you want to implement it.

I would suggest one class to represent a node and one for edges:

class Node {
    Node previousNode;
    double weight;    // actual cost to reach this node
    ...  // problem specific attributes (id, x, y)
}

class Edge {
    Node node1, node2;
    double weight;    // cost to 'use' this edge
    ... // problem specific attributes (road number?)
}

Eventually it would be helpful to add a field to Node to hold all Edges that start/ends at that Node.

The Edge class maybe be not necessary for navigation if cost equals distance and the distance between two connected nodes is just the Euclidean distance.

Answer 2

Because you are going to use heuristics I would recommend:

class Node {
    Node prevNode;  //parent node
    int x;
    int y;
    int gn;    // cost to reach this node
    float hn;  // node's heuristic value
    float fn;  // evaluation function. Optional, you could do gn + hn
}

Before expanding a node you need to calculate the distance to reach each of its child nodes.

When you expand a node (using evaluation function):

g (Node) = g (Parent) + distance (Parent-Node)

f (Node) = g (Node) + h (Node)