Java 如何在线性时间内从大型OSM映射构建具有邻接列表的无向图
这是我第一次用地图编写web应用程序 我试图从给定的OSM映射中为每个节点创建具有邻接列表的无向图 当我在小地图上测试时，一切正常。Java 如何在线性时间内从大型OSM映射构建具有邻接列表的无向图,java,algorithm,graph,openstreetmap,adjacency-list,Java,Algorithm,Graph,Openstreetmap,Adjacency List,这是我第一次用地图编写web应用程序 我试图从给定的OSM映射中为每个节点创建具有邻接列表的无向图 当我在小地图上测试时，一切正常。 我解组OSM映射（相当于XML文件），然后从收到的OSM对象创建一个无向图 当我尝试从较大的贴图创建图形时，问题就开始了 例如，以6MB大小的地图为例： 节点数：24828 途径数：4535 在每种情况下，平均5个节点的数量。 所有这些加起来将是：24828*4535*5=562974900次迭代 直观地说，为了找到每个节点的邻居，我需要从节点列表中的每个节点2中
我解组OSM映射（相当于XML文件），然后从收到的OSM对象创建一个无向图 当我尝试从较大的贴图创建图形时，问题就开始了 例如，以6MB大小的地图为例：
节点数：24828
途径数：4535
在每种情况下，平均5个节点的数量。
所有这些加起来将是：24828*4535*5=562974900次迭代 直观地说，为了找到每个节点的邻居，我需要从节点列表中的每个节点2中以各种方式查看每个节点1。
如果节点1等于节点2，我需要将下一个和上一个节点作为其邻居。
我花了大约1:30分钟的时间： 我正在构建一个在智能手机上运行的web应用程序，并计算运行的随机路径。
如果用户只需等待1:30分钟即可创建图形，则该图形将无法使用 我熟悉BFS\DFS，但在这种情况下它们不会帮助我，因为我需要构建图表 也许还有其他有效的方法来创建节点的邻接列表 如何建立邻接列表：
public static List<Node> GetNodesFromXML(Osm i_Osm) {
List<Node> o_Nodes = new ArrayList<Node>();
long id;
double latitude;
double longtitude;
Map<Node, List<Node>> o_AdjList = new HashMap<Node, List<Node>>();
for (Osm.Node nodeChild : i_Osm.getNode()) {
id = nodeChild.getId();
latitude = nodeChild.getLat();
longtitude = nodeChild.getLon();
Node node = new Node(id, latitude, longtitude);
for (Osm.Way way : i_Osm.getWay()) // go over the node list of the specific way objects
{
for (Osm.Way.Nd nd : way.getNd()) {
// some manipulation to create the adjacency list
}
}
//List<Long> nodeAdjacenciesByRef = getNodeAdjacenciesByRef(node, i_Osm.getWay(), i_Osm.getNode());
// List<Edge> nodeAdjacencies = getNodeAdjacencies1(node, i_Osm.getWay(), i_Osm.getNode());
// List<Edge> nodeAdjacencies = getAdjacenciesListFromRefList(node, nodeAdjacenciesByRef, i_Osm.getNode());
// node.SetAdjacencies(nodeAdjacencies);
o_Nodes.add(node);
}
for(Node node : o_Nodes)
{
}
o_Nodes = updateAdjacenciesToAllNodes(o_Nodes);
return o_Nodes;
}
// Node.java
public class Node implements Comparable<Node>
{
private long m_Id;
private List<Edge> m_Adjacencies = new ArrayList<Edge>();
private double m_Longtitude;
private double m_Latitude;
private Node m_Prev;
private double m_MinDistance = Double.POSITIVE_INFINITY; // this is for Dijkstra Algorithm
//used to reconstruct the track when we found the approproate length of the user request
//from the current level to the destination
public Node(long i_Id, double i_Latitude, double i_Longtitude)
{
m_Id = i_Id;
m_Latitude = i_Latitude;
m_Longtitude = i_Longtitude;
}
...
}
// Graph.java
private List<Node> m_Nodes = new ArrayList<>();
private List<Way> m_Ways = new ArrayList<>();
private List<Relation> m_Relations = new ArrayList<>();
private Bounds m_Bounds;
public Graph(List<Node> i_Nodes, List<Way> i_Ways, List<Relation> i_Relations, Bounds i_Bounds) {
m_Nodes = i_Nodes;
m_Ways = i_Ways;
m_Relations = i_Relations;
m_Bounds = i_Bounds;
}
...
}
// Edge.java
public class Edge {
Node m_Source;
Node m_Destination;
double m_Weight;
public Edge(Node i_Source, Node i_Destination, double i_Weight) {
m_Source = i_Source;
m_Destination = i_Destination;
m_Weight = i_Weight;
}
...
}
公共静态列表GetNodesFromXML（Osm i_Osm）{
List o_Nodes=new ArrayList（）；
长id；
双纬度；
双长；
Map o_AdjList=新HashMap（）；
for（Osm.Node nodeChild:i_Osm.getNode（））{
id=nodeChild.getId（）；
纬度=nodeChild.getLat（）；
longtudent=nodeChild.getLon（）；
节点=新节点（id、纬度、经度）；
for（Osm.Way:i_Osm.getWay（））//查看特定路径对象的节点列表
{
for（Osm.Way.Nd Nd:Way.getNd（））{
//创建邻接列表的一些操作
}
}
//List nodeadjacesbyref=getnodeadjacesbyref（node，i_Osm.getWay（），i_Osm.getNode（））；
//List nodeadjacenties=getnodeadjacenties1（node，i_Osm.getWay（），i_Osm.getNode（））；
//List nodedjacenties=getAdjacesListFromRefList（node，nodedjacesByRef，i_Osm.getNode（））；
//node.SetAdjaces（NodeAdjaces）；
o_节点。添加（节点）；
}
用于（节点：o_节点）
{
}
o_节点=UpdatedJacEnciestoAllNodes（o_节点）；
返回o_节点；
}
public static List<Node> GetNodesFromXML(Osm i_Osm) {
List<Node> o_Nodes = new ArrayList<Node>();
long id;
double latitude;
double longtitude;
Map<Node, List<Node>> o_AdjList = new HashMap<Node, List<Node>>();
for (Osm.Node nodeChild : i_Osm.getNode()) {
id = nodeChild.getId();
latitude = nodeChild.getLat();
longtitude = nodeChild.getLon();
Node node = new Node(id, latitude, longtitude);
for (Osm.Way way : i_Osm.getWay()) // go over the node list of the specific way objects
{
for (Osm.Way.Nd nd : way.getNd()) {
// some manipulation to create the adjacency list
}
}
//List<Long> nodeAdjacenciesByRef = getNodeAdjacenciesByRef(node, i_Osm.getWay(), i_Osm.getNode());
// List<Edge> nodeAdjacencies = getNodeAdjacencies1(node, i_Osm.getWay(), i_Osm.getNode());
// List<Edge> nodeAdjacencies = getAdjacenciesListFromRefList(node, nodeAdjacenciesByRef, i_Osm.getNode());
// node.SetAdjacencies(nodeAdjacencies);
o_Nodes.add(node);
}
for(Node node : o_Nodes)
{
}
o_Nodes = updateAdjacenciesToAllNodes(o_Nodes);
return o_Nodes;
}
// Node.java
public class Node implements Comparable<Node>
{
private long m_Id;
private List<Edge> m_Adjacencies = new ArrayList<Edge>();
private double m_Longtitude;
private double m_Latitude;
private Node m_Prev;
private double m_MinDistance = Double.POSITIVE_INFINITY; // this is for Dijkstra Algorithm
//used to reconstruct the track when we found the approproate length of the user request
//from the current level to the destination
public Node(long i_Id, double i_Latitude, double i_Longtitude)
{
m_Id = i_Id;
m_Latitude = i_Latitude;
m_Longtitude = i_Longtitude;
}
...
}
// Graph.java
private List<Node> m_Nodes = new ArrayList<>();
private List<Way> m_Ways = new ArrayList<>();
private List<Relation> m_Relations = new ArrayList<>();
private Bounds m_Bounds;
public Graph(List<Node> i_Nodes, List<Way> i_Ways, List<Relation> i_Relations, Bounds i_Bounds) {
m_Nodes = i_Nodes;
m_Ways = i_Ways;
m_Relations = i_Relations;
m_Bounds = i_Bounds;
}
...
}
// Edge.java
public class Edge {
Node m_Source;
Node m_Destination;
double m_Weight;
public Edge(Node i_Source, Node i_Destination, double i_Weight) {
m_Source = i_Source;
m_Destination = i_Destination;
m_Weight = i_Weight;
}
...
}
//Node.java
公共类节点实现了可比较的
{
私人长m_Id；
私有列表m_邻接=新ArrayList（）；
私人双m_长；
私人双m_纬度；
私有节点m_Prev；
private double m_MinDistance=double.POSITIVE_INFINITY；//这是针对Dijkstra算法的
//用于在找到用户请求的适当长度时重建轨迹
//从当前级别到目标级别
公共节点（长i_Id、双i_纬度、双i_长度）
{
m_Id=i_Id；
m_纬度=i_纬度；
m_longtude=i_longtude；
}
...
}
//Graph.java
私有列表m_节点=新的ArrayList（）；
private List m_Ways=new ArrayList（）；
private List m_Relations=new ArrayList（）；
私有界m_界；
公共图（列表i_节点、列表i_方式、列表i_关系、边界i_边界）{
m_节点=i_节点；
m_路=i_路；
m_关系=i_关系；
m_界=i_界；
}
...
}
//java
公共阶级边缘{
节点m_源；
节点m_目的地；
双倍重量；
公共边缘（节点i_源、节点i_目标、双i_权重）{
m_源=i_源；
m_目的地=i_目的地；
m_重量=i_重量；
}
...
}
我使用HashMap。这样我就可以得到O（1）中的每个节点。
因此，我在所有节点上运行一次（1秒或更短），并创建此映射。
完成此映射后，我可以在没有外部循环的情况下以各种方式传递每个节点。
在重新设计之后，整个过程大约需要3秒钟 因此，解决方案如下：
public static List<Node> GetNodesFromXML(Osm i_Osm) {
List<Node> o_Nodes = new ArrayList<Node>();
long id;
double latitude;
double longtitude;
Map<Long, Node> o_NodesByRef = new HashMap<Long, Node>();
for (Osm.Node nodeChild : i_Osm.getNode()) {
id = nodeChild.getId();
latitude = nodeChild.getLat();
longtitude = nodeChild.getLon();
Node node = new Node(id, latitude, longtitude);
//o_Nodes.add(node);
o_NodesByRef.put(id, node);
}
o_Nodes = addAdjacencies(o_NodesByRef, i_Osm.getWay());
//o_Nodes = updateAdjacenciesToAllNodes(o_Nodes);
return o_Nodes;
}
private static List<Node> addAdjacencies(Map<Long, Node> i_NodesByRef , List<Osm.Way> i_Ways) {
List<Node> o_Nodes = new ArrayList<Node>();
long ndId;
int nodeIndex;
int lastNodeIndex;
Node previousNode;
Node nextNode;
double weight;
//System.out.println(i_SourceNode.getNodeId());
for (Osm.Way way : i_Ways) // go over the node list of the specific way objects
{
if (way.getNd().size() > 1) {
for (Osm.Way.Nd nd : way.getNd()) {
if(i_NodesByRef.containsKey(nd.getRef()))// found node in way
{
Node node = i_NodesByRef.get(nd.getRef());
nodeIndex = way.getNd().indexOf(nd);
Edge edge1;
Edge edge2;
Osm.Way.Nd temp_nd;
lastNodeIndex = way.getNd().size() - 1;
if (nodeIndex == 0) // node is the first in the way
{
temp_nd = way.getNd().get(nodeIndex + 1);
nextNode = i_NodesByRef.get(temp_nd.getRef());
weight = CoordinateMath.getDistanceBetweenTwoNodes(node, nextNode);
edge1 = new Edge(node, nextNode, weight);
i_NodesByRef.get(node.getNodeId()).getAdjacencies().add(edge1);
} else if (lastNodeIndex == nodeIndex) // node is the last
{
temp_nd = way.getNd().get(nodeIndex - 1);
previousNode = i_NodesByRef.get(temp_nd.getRef());
weight = CoordinateMath.getDistanceBetweenTwoNodes(node, previousNode);
edge1 = new Edge(node, previousNode, weight);
i_NodesByRef.get(node.getNodeId()).getAdjacencies().add(edge1);
} else // node is in the middle
{
temp_nd = way.getNd().get(nodeIndex - 1);
previousNode = i_NodesByRef.get(temp_nd.getRef());
weight = CoordinateMath.getDistanceBetweenTwoNodes(node, previousNode);
// node -> previousNode
edge1 = new Edge(node, previousNode, weight);
i_NodesByRef.get(node.getNodeId()).getAdjacencies().add(edge1);
temp_nd = way.getNd().get(nodeIndex + 1);
nextNode = i_NodesByRef.get(temp_nd.getRef());
weight = CoordinateMath.getDistanceBetweenTwoNodes(node, nextNode);
// node -> nextNode
edge2 = new Edge(node, nextNode, weight);
i_NodesByRef.get(node.getNodeId()).getAdjacencies().add(edge2);
}
}
}
}
}
for(Map.Entry<Long, Node> entry : i_NodesByRef.entrySet())
{
o_Nodes.add(entry.getValue());
}
return o_Nodes;
}
公共静态列表GetNodesFromXML（Osm i_Osm）{
List o_Nodes=new ArrayList（）；
长id；
双纬度；
双长；
Map o_NodesByRef=新HashMap（）；
for（Osm.Node nodeChild:i_Osm.getNode（））{
id=nodeChild.getId（）；
纬度=nodeChild.getLat（）；
longtudent=nodeChild.getLon（）；
节点=新节点（id、纬度、经度）；
//o_节点。添加（节点）；
o_NodesByRef.put（id，node）；
}
o_Nodes=addadjaccies（o_NodesByRef，i_Osm.getWay（））；
//o_节点=UpdatedJacEnciestoAllNodes（o_节点）；
返回o_节点；
}
私有静态列表添加邻接（映射i_节点ByRef、列表i_方式）{
List o_Nodes=new ArrayList（）；
长ndId；
int节点索引；
int lastNodeIndex；
节点前一节点；
节点下一节点；
双倍重量；
//System.out.println（i_SourceNode.getNodeId（））；
for（Osm.Way-Way:i_-Ways）//查看特定Way对象的节点列表
{
如果（way.getNd（）.size（）>1）{
for（Osm.Way.Nd Nd:Way.getNd（））{
if（i_NodesByRef.containsKey（nd.getRef（））//在路径中找到节点
{
Node Node=i_NodesByRef.get（nd.getRef（））；
nodeIndex=way.getNd（）.indexOf（nd）；
边缘1；
for (Osm.Way way : i_Osm.getWay()) {
//I will asume the getNd() returns some sort of array or list an you can access the next or previous element
for (Osm.Way.Nd nd : way.getNd()) {
if(o_AdjList contains key nd){
o.AdjList.get(nd).add(nextNd);
} else {
o.AdjList.put(nd,nextNd);
}
}