Question

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

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

需要绕过包含字符串'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;
}

Answer 1

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

创建空结果列表
调用getTerminalSymbolFor（firstkey，firstkey，resultlist）
getTerminalSymbolFor（String root，String key，resultlist）
- 在ArrayList中搜索键入值
- 如果没有找到：将root = key添加到resultlist并返回
  - else：return getTerminalSymbolFor（root，value，resultlist）（do recursion）

根据您的描述，我不确定您是否以任何符号开头，第一个或非终端符号。但都可以调整。我想你可能想传入一个“已解决的列表”而不是返回找到的那个你将它添加到lis

顺便说一句：这是非常低效的。

Answer 2

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

由于

试图用Java编写递归函数

2 个答案: