Java 获取从给定起始节点移动的路径

我有一些节点连接，节点之间的距离固定为1

节点代表城市，因此我可以从城市到我可以旅行的城市。也是一个起始节点

节点是双向连接的

现在，我想找到从起始节点到下一个最近节点的移动顺序，如果节点的距离相同，那么根据优先级选择节点

示例：

from = [1,1,2, 3,1], to = [2,3,4,5,5]

starting node = 1

图表如下所示：

4
|
|
2
|
|
1 -- 3
|   /
|/  
5

因此，我将从1:：2-->3-->5-->4开始这样旅行

说明： 从1开始，节点2、5、3的固定距离为1，节点4的固定距离为2。如果我们对2,5,3进行排序，我们得到2,3,5。首先我们达到2，3，5，然后是4

如果我的方法是：

static List<Integer> process(int nodeCount, List<Integer> from, List<Integer> to, int startingnode) {

    Map<Integer, List<Integer>> map = new HashMap<>();
    for (int i = 0; i < from.size(); i++) {
        int frm = from.get(i);
        int tov = to.get(i);
        List<Integer> a = map.getOrDefault(frm, new ArrayList<>());
        List<Integer> b = map.getOrDefault(tov, new ArrayList<>());
        a.add(tov);
        b.add(frm);
        map.put(frm, a);
        map.put(tov, b);
    }

    System.out.println(map);
    List<Integer> a = map.get(startingnode);
    a.sort(null);
    System.out.println(a);
    //a.add(startingnode);
    //map.keySet().removeAll(a);
    //System.out.println(map);
    return null;

}

静态列表过程（int-nodeCount、List-from、List-to、int-startingnode）{
Map Map=newhashmap（）；
对于（int i=0；i

---

在这里我尝试了，但是我能够得到距离为1的节点。但是我被困在如何读取其他节点上。我正在使用哈希映射来存储节点。

对不起，我没有意识到以from/to的形式构造图 我们需要的BFS如下：

公共字符串bfs（int v，int N，Map adjList）{
队列q=新的LinkedList（）；
q、 添加（v）；
Map orderMap=新建LinkedHashMap（）；
int[]距离=新的int[N]；
Arrays.fill（距离，0）；//0表示未访问
而（！q.isEmpty（））{
int r=q.poll（）；
for（int s:adjList.getOrDefault（r，new ArrayList（）））{
如果（距离=0）{
q、 添加（s）；
距离[s]=距离[r]+1；
//将节点添加到相应级别的映射中
设置我的级别=
getOrDefault（距离[r]+1，新树集（））；
myLevel.add（s）；
orderMap.put（距离[r]+1，myLevel）；
}
}
}
return array.toString(
orderMap.values（）.stream（）.flatMap（Collection:：stream.toArray（））；
}
/**
*图是一种邻接列表表示法。
*我们需要参数N，以便存储顶点
*在具有适当索引的数组中。
*由于数组的索引为0，因此我们使N个顶点比总顶点多1个
*/
公共静态void main（字符串[]args）{
Map adjList=新的HashMap（）；
//[1,1,2,3,1]，to=[2,3,4,5,5]
列表1=列表（2,3,5）；
清单二=第（4）项清单；
清单三=第（5）项清单；
调整列表。放置（1，个）；
adjList.put（2，2）；
adjList.put（3，3）；
系统输出println（bfs（1，6，adjList））；
}

---

我正在使用TreeSet，以便我们可以根据您的需要对数字进行排序。

我为您的案例实现了一个改进的

Dijkstra

算法。有一个很好的实现。

节点

类具有用于计算距离的

距离

和相邻列表

import java.util.HashSet；
导入java.util.Set；
公共类节点{
私有整数值；
私有整数距离=Integer.MAX_值；
私有集邻接节点=新HashSet（）；
公共节点（整数值）{
这个值=值；
}
公共整数getValue（）{
返回值；
}
公共无效添加相邻节点（其他节点）{
添加（其他）；
}
公共整数getDistance（）{
返回距离；
}
公共空间设置距离（整数距离）{
这个距离=距离；
}
公共集getAdjacentNodes（）{
返回邻接节点；
}
}

主类

import java.util.*；
导入java.util.stream.collector；
公共班机{
公共静态void main（字符串[]args）{
List from=Arrays.asList（1,1,2,3,1）；
List to=Arrays.asList（2,3,4,5,5）；
列表结果=过程（5，从，到，1）；
系统输出打印项次（结果）；
}
静态列表进程（int nodeCount、List from、List to、int startingNode）{
//使用值创建节点映射
Map nodesMap=newhashmap（）；
对于（int i=1；i{
//如果距离相等，请与值进行比较
如果（o1.getDistance（）.）等于（o2.getDistance（））{
返回o1.getValue（）.compareTo（o2.getValue（））；
}
//与距离相比
返回o1.getDistance（）.compareTo（o2.getDistance（））；
})
.map（节点：：getValue）
.collect（Collectors.toList（））；
返回分类列表；
}
}

输出：

[1, 2, 3, 5, 4]

---

是你的目标，用最近到最远的节点排序，如果有节点距离相同，用升序排序，对吗？@İsmailDurmaz，没错。我的输入只包含数组。但这里我看到了TreeNode，如何从数组中得到它？你能帮个忙吗？还有，我看到root.left，root.right，我的例子中没有这样的节点。