编写一个路由程序，Java中递归的难度

所以我在写一个程序，在地铁系统中把一个人从一个车站送到另一个车站。我的想法是：

• 在起点站，找出它在哪条线上。然后检查它是否与目标站在同一条线上
• 如果是，则打印所需的路径。这部分确实有效，我已经测试过了
• 如果没有，则在每条线上上下移动一个止动块，并进行相同的检查

它给了我一个无法解决的堆栈溢出。试图调试但没有结果

public ArrayList<Station> findRoutesBetween(Station start, Station target) {
    ArrayList<Station> path = new ArrayList<Station>();

    for (Route route : findRoutes(start)) {
        ArrayList<Station> stops = route.getStops();
        boolean sameRoute = findRoutes(target).contains(route);
        int stopIdstart = stops.indexOf(start);
        int stopIdtarget = stops.indexOf(target);
        if (sameRoute && stops.contains(start)) {
            if (stopIdtarget > stopIdstart) {
                path.addAll((stops.subList(stopIdstart, stopIdtarget + 1)));
                return path;
            } else {
                List<Station> temp = stops.subList(stopIdstart, stopIdtarget + 1);
                Collections.reverse(temp);
                path.addAll(temp);
                return path;
            }
        } else {
            if (stopIdstart != stops.size() - 1) {
                System.out.println("hh");
                ArrayList<Station> t = findRoutesBetween(stops.get(stopIdstart + 1), target);
                System.out.println(t.toString());
            }
            if (stopIdstart != 0) {
                System.out.println("hh");
                ArrayList<Station> t = findRoutesBetween(stops.get(stopIdstart - 1), target);
                System.out.println(t.toString());
            }
        }

    }
    return path;
}

public ArrayList findulotesbetween（站点开始，站点目标）{
ArrayList路径=新建ArrayList（）；
用于（路线：Findrootes（起点））{
ArrayList stops=route.getStops（）；
布尔sameRoute=findrootes（目标）.contains（路由）；
int stopIdstart=stops.indexOf（开始）；
int stopIdtarget=stops.indexOf（目标）；
if（samerout&&stops.contains（start））{
如果（stopIdtarget>stopIdstart）{
addAll（（stops.subList（stopIdstart，stopIdtarget+1））；
返回路径；
}否则{
列表温度=停止。子列表（stopIdstart、stopIdtarget+1）；
收藏。反向（临时）；
addAll路径（temp）；
返回路径；
}
}否则{
if（stopIdstart！=stops.size（）-1）{
System.out.println（“hh”）；
ArrayList t=findLotesBetween（stops.get（stopIdstart+1），target）；
System.out.println（t.toString（））；
}
如果（stopIdstart！=0）{
System.out.println（“hh”）；
ArrayList t=findLotesBetween（stops.get（stopIdstart-1），target）；
System.out.println（t.toString（））；
}
}
}
返回路径；
}

---

函数findrootes（）只返回停止点所在的所有行

您的实施不会忽略您已经检查或继续的电台。这意味着在某个时刻，您可能会通过给定的路线从A站到B站。然后，当你在车站B时，你检查所有可能的车站并再次看到车站A。然后你又回到A站，重新开始，再次找到B站。现在，在无休止的递归方法调用中，您在这些站之间来回跳跃，直到您得到一个

stackoverflowerrror

保留已检查的电台列表，当电台位于列表中时，不要再次检查。所以你会得到这样的结果：

好的，我在K站，根据可用路线查看R站、G站、W站、Z站、C站、I站和L站。然而，我跳过了W站、Z站和C站，因为我已经在那里了。所以让我们接下来只检查R站，G站，I站和L站

出于调试目的，您可以打印进入方法的参数（或来自

站点

对象的一些数据，如站点名称）。通过这种方式，您可能已经注意到，在您的方法中看到相同的站点重复它们自己。

线程“main”java.lang.StackOverflowerError中的异常

位于project.Map.findrootesBetween（Map.java:50）

位于project.Map.findrootesBetween（Map.java:55）

这些行号是进行递归调用的地方。