尝试用Java编写递归函数

我尝试了很多，但无法为此编写递归函数。 例如，我有下面的列表，其中保存映射（不是映射，因为键是重复的）：

需要绕过包含字符串“gateway”的映射。我们可以看到，review1映射到exclusivegateway4，exclusivegateway4映射到inclusivegateway1，然后inclusivegateway1映射到T_Review、L_Review、SP_Review和M_Review。因此，绕过所有“网关”字符串，最终映射应为：

[[review1, T_Review],
review1, L_Review],
review1, SP_Review],
review1, M_Review]]

我需要使这个函数递归，因为其中可能有更多的网关。我知道这要求太高了。但是我在代码中遗漏了一些东西

谢谢， 尼汀 下面是没有递归的代码

private void decorateList(ArrayList<ArrayList<String>> mappingList ){
    for(ArrayList<String> list: mappingList){
        String src = list.get(0);
        String target = list.get(1);
        if(target.contains("gateway")){
            listToRemove.add(list);

            for(ArrayList<String> list2: mappingList){
                String list2Src = list2.get(0);
                String list2Target = list2.get(1);
                if(list2Src.equals(target)){

                    if(list2Target.contains("gateway")){
                        for(ArrayList<String> list4: mappingList){
                            String list4Src = list4.get(0);
                            String list4Target = list4.get(1);
                            if(list4Src.equals(list2Target)){
                                ArrayList<String> list5 = new ArrayList<String>();
                                list5.add(src);
                                list5.add(list4Target);
                                listToAdd.add(list5);
                            }
                        }
                        break;
                    }
                    ArrayList<String> list3 = new ArrayList<String>();
                    list3.add(src);
                    list3.add(list2Target);
                    listToRemove.add(list2);
                    listToAdd.add(list3);
                }

            }

        }

    }

    Iterator<ArrayList<String>> itr = mappingList.iterator();
    while (itr.hasNext()){
        ArrayList<String> list = itr.next();
        if (listToRemove.contains(list)){
            itr.remove();
        }
    }
    mappingList.addAll(listToAdd);
}

    ArrayList<ArrayList<String>> mappingList2 = mappingList;
    for(ArrayList<String> list : mappingList2){
    // Below line is calling the recursive function 
    mappingList = decorateListRecursive(mappingList, list);
    }

private ArrayList<ArrayList<String>> decorateListRecursive(ArrayList<ArrayList<String>> mappingList, ArrayList<String> list){
        System.out.println("Count " + count);
        count++;
        String src = list.get(0);
        String target = list.get(1);
        if(target.contains("gateway")){
            listToRemove.add(list);

            Iterator<ArrayList<String>> itr = mappingList.iterator();
            while(itr.hasNext()){
                ArrayList<String> list2 = itr.next();
                String list2Src = list2.get(0);
                String list2Target = list2.get(1);
                if(list2Src.equals(target)){
                    if(list2Target.contains("gateway")){
                        decorateListRecursive(mappingList, list2);
                    }
                    ArrayList<String> list3 = new ArrayList<String>();
                    list3.add(src);
                    list3.add(list2Target);
                    listToAdd.add(list3);
                }else{

                }
            }

        }
return mappingList;
}

private void装饰列表（ArrayList映射列表）{
用于（ArrayList列表：mappingList）{
字符串src=list.get（0）；
String target=list.get（1）；
if（target.contains（“网关”））{
listToRemove.add（列表）；
用于（ArrayList列表2:mappingList）{
字符串list2Src=list2.get（0）；
字符串list2Target=list2.get（1）；
if（list2Src.equals（目标））{
if（list2Target.contains（“网关”））{
for（ArrayList列表4:mappingList）{
字符串list4Src=list4.get（0）；
字符串list4Target=list4.get（1）；
if（list4Src.equals（list2Target））{
ArrayList list5=新的ArrayList（）；
清单5.添加（src）；
列表5.添加（列表4目标）；
列表添加（列表5）；
}
}
打破
}
ArrayList list3=新的ArrayList（）；
清单3.add（src）；
列表3.添加（列表2目标）；
listToRemove.add（list2）；
列表添加（列表3）；
}
}
}
}
迭代器itr=mappingList.Iterator（）；
while（itr.hasNext（））{
ArrayList list=itr.next（）；
if（listToRemove.contains（列表））{
itr.remove（）；
}
}
mappingList.addAll（listToAdd）；
}

下面是我用递归编写的代码

private void decorateList(ArrayList<ArrayList<String>> mappingList ){
    for(ArrayList<String> list: mappingList){
        String src = list.get(0);
        String target = list.get(1);
        if(target.contains("gateway")){
            listToRemove.add(list);

            for(ArrayList<String> list2: mappingList){
                String list2Src = list2.get(0);
                String list2Target = list2.get(1);
                if(list2Src.equals(target)){

                    if(list2Target.contains("gateway")){
                        for(ArrayList<String> list4: mappingList){
                            String list4Src = list4.get(0);
                            String list4Target = list4.get(1);
                            if(list4Src.equals(list2Target)){
                                ArrayList<String> list5 = new ArrayList<String>();
                                list5.add(src);
                                list5.add(list4Target);
                                listToAdd.add(list5);
                            }
                        }
                        break;
                    }
                    ArrayList<String> list3 = new ArrayList<String>();
                    list3.add(src);
                    list3.add(list2Target);
                    listToRemove.add(list2);
                    listToAdd.add(list3);
                }

            }

        }

    }

    Iterator<ArrayList<String>> itr = mappingList.iterator();
    while (itr.hasNext()){
        ArrayList<String> list = itr.next();
        if (listToRemove.contains(list)){
            itr.remove();
        }
    }
    mappingList.addAll(listToAdd);
}

    ArrayList<ArrayList<String>> mappingList2 = mappingList;
    for(ArrayList<String> list : mappingList2){
    // Below line is calling the recursive function 
    mappingList = decorateListRecursive(mappingList, list);
    }

private ArrayList<ArrayList<String>> decorateListRecursive(ArrayList<ArrayList<String>> mappingList, ArrayList<String> list){
        System.out.println("Count " + count);
        count++;
        String src = list.get(0);
        String target = list.get(1);
        if(target.contains("gateway")){
            listToRemove.add(list);

            Iterator<ArrayList<String>> itr = mappingList.iterator();
            while(itr.hasNext()){
                ArrayList<String> list2 = itr.next();
                String list2Src = list2.get(0);
                String list2Target = list2.get(1);
                if(list2Src.equals(target)){
                    if(list2Target.contains("gateway")){
                        decorateListRecursive(mappingList, list2);
                    }
                    ArrayList<String> list3 = new ArrayList<String>();
                    list3.add(src);
                    list3.add(list2Target);
                    listToAdd.add(list3);
                }else{

                }
            }

        }
return mappingList;
}

ArrayList mappingList2=mappingList；
用于（ArrayList列表：mappingList2）{
//下面一行是调用递归函数
mappingList=decorateListRecursive（mappingList，list）；
}
私有ArrayList decorateListCursive（ArrayList映射列表，ArrayList列表）{
系统输出打印项次（“计数”+计数）；
计数++；
字符串src=list.get（0）；
String target=list.get（1）；
if（target.contains（“网关”））{
listToRemove.add（列表）；
迭代器itr=mappingList.Iterator（）；
while（itr.hasNext（））{
ArrayList list2=itr.next（）；
字符串list2Src=list2.get（0）；
字符串list2Target=list2.get（1）；
if（list2Src.equals（目标））{
if（list2Target.contains（“网关”））{
装饰性手写体（映射列表，列表2）；
}
ArrayList list3=新的ArrayList（）；
清单3.add（src）；
列表3.添加（列表2目标）；
列表添加（列表3）；
}否则{
}
}
}
返回映射列表；
}

嗯，递归（据我所知，任务是：）

• 创建空结果列表
• 调用getTerminalSymbolFor（firstkey、firstkey、resultlist）

• getTerminalSymbolFor（字符串根、字符串键、结果列表）
  • 在ArrayList中搜索键到值
  • 如果未找到：将root=key添加到resultlist并返回
    • else：返回getTerminalSymbolFor（根、值、结果列表）（执行递归）

根据您的描述，我不确定您是否以任何符号开头，第一个符号还是非终端符号。但一切都可以调整。我认为您可能希望传入一个“已解决列表”，而不是返回找到的列表，而是将其添加到lis中

---

顺便说一句：这是可怕的低效。

埃克斯算法帮助我找到了解决方案。我循环遍历列表并递归调用列表，直到找到所需的项。然后将该项添加到结果列表中

---

谢谢

您能编写一个不使用递归的解决方案吗？这将是一种开始方式。“要求家庭作业帮助的问题必须包括到目前为止你为解决问题所做的工作的摘要，以及你解决问题所遇到的困难的描述。”这是我编写的没有递归的代码。我正试图使其递归，但没有达到确切的效果。我已经创建了其他递归函数，唯一的问题是它必须再遍历一次（我想）。这不是我没有做的作业。我只是缺少了一个概念，我发布了这个问题。我还在努力。谢谢你的帮助。你知道吗，你的想法帮助我写了这段代码，虽然我不得不添加一些东西，但它给了我正确的方向。非常感谢。