可以使用递归的方法来实现：
```java
import java.util.*;
public class FindPath {
public static void main(String[] args) {
// 定义数据结构
List<Map<String, Object>> data = new ArrayList<>();
Map<String, Object> node1 = new HashMap<>();
node1.put("id", "1");
node1.put("name", "测试1");
node1.put("pId", "0");
node1.put("type", "group");
List<Map<String, Object>> children1 = new ArrayList<>();
Map<String, Object> node11 = new HashMap<>();
node11.put("id", "11");
node11.put("name", "测试11");
node11.put("pId", "1");
node11.put("type", "group");
List<Map<String, Object>> children11 = new ArrayList<>();
Map<String, Object> node111 = new HashMap<>();
node111.put("id", "111");
node111.put("name", "测试111");
node111.put("pId", "11");
node111.put("type", "group");
List<Map<String, Object>> children111 = new ArrayList<>();
Map<String, Object> node1111 = new HashMap<>();
node1111.put("id", "1111");
node1111.put("name", "测试1111");
node1111.put("pId", "111");
children111.add(node1111);
Map<String, Object> node1112 = new HashMap<>();
node1112.put("id", "1112");
node1112.put("name", "测试1112");
node1112.put("pId", "111");
children111.add(node1112);
node111.put("children", children111);
children11.add(node111);
Map<String, Object> node112 = new HashMap<>();
node112.put("id", "112");
node112.put("name", "测试112");
node112.put("pId", "11");
List<Map<String, Object>> children112 = new ArrayList<>();
Map<String, Object> node1121 = new HashMap<>();
node1121.put("id", "1121");
node1121.put("name", "测试1121");
node1121.put("pId", "112");
children112.add(node1121);
node112.put("children", children112);
children11.add(node112);
Map<String, Object> node113 = new HashMap<>();
node113.put("id", "113");
node113.put("name", "测试113");
node113.put("pId", "11");
children11.add(node113);
node11.put("children", children11);
children1.add(node11);
Map<String, Object> node12 = new HashMap<>();
node12.put("id", "12");
node12.put("name", "测试12");
node12.put("pId", "1");
node12.put("type", "group");
List<Map<String, Object>> children12 = new ArrayList<>();
Map<String, Object> node121 = new HashMap<>();
node121.put("id", "121");
node121.put("name", "测试121");
node121.put("pId", "12");
children12.add(node121);
node12.put("children", children12);
children1.add(node12);
Map<String, Object> node13 = new HashMap<>();
node13.put("id", "13");
node13.put("name", "测试13");
node13.put("pId", "1");
children1.add(node13);
Map<String, Object> node14 = new HashMap<>();
node14.put("id", "14");
node14.put("name", "测试14");
node14.put("pId", "1");
children1.add(node14);
node1.put("children", children1);
data.add(node1);
Map<String, Object> node2 = new HashMap<>();
node2.put("id", "2");
node2.put("name", "测试2");
node2.put("pId", "0");
List<Map<String, Object>> children2 = new ArrayList<>();
Map<String, Object> node21 = new HashMap<>();
node21.put("id", "21");
node21.put("name", "测试21");
node21.put("pId", "2");
List<Map<String, Object>> children21 = new ArrayList<>();
Map<String, Object> node211 = new HashMap<>();
node211.put("id", "211");
node211.put("name", "测试211");
node211.put("pId", "21");
children21.add(node211);
Map<String, Object> node212 = new HashMap<>();
node212.put("id", "212");
node212.put("name", "测试212");
node212.put("pId", "21");
children21.add(node212);
node21.put("children", children21);
children2.add(node21);
Map<String, Object> node22 = new HashMap<>();
node22.put("id", "22");
node22.put("name", "测试22");
node22.put("pId", "2");
children2.add(node22);
node2.put("children", children2);
data.add(node2);
// 查找节点路径
String targetId = "1111";
List<String> path = findPath(data, targetId);
System.out.println("节点 " + targetId + " 的完整路径为：");
for (String nodeId : path) {
System.out.print(nodeId + " -> ");
}
}
// 递归查找节点路径
public static List<String> findPath(List<Map<String, Object>> data, String targetId) {
for (Map<String, Object> node : data) {
String nodeId = (String) node.get("id");
if (nodeId.equals(targetId)) {
List<String> path = new ArrayList<>();
path.add(nodeId);
return path;
} else {
List<Map<String, Object>> children = (List<Map<String, Object>>) node.get("children");
if (children != null && !children.isEmpty()) {
List<String> path = findPath(children, targetId);
if (path != null) {
path.add(0, nodeId);
return path;
}
}
}
}
return null;
}
}
```
输出结果为：
```
节点 1111 的完整路径为：
1 -> 11 -> 111 -> 1111 ->
```
6729
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
