Java 用递归实现数列的置换

我试图通过创建ArrayList的置换来学习递归：

 {1,2,3}

但是递归调用的概念一直困扰着我。我知道如何进行迭代求解。但是，有没有一种系统的方法可以将迭代解转换为递归解呢

private static ArrayList<ArrayList<Integer>> permutate(ArrayList<Integer> list) {
    ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();

    result.add(new ArrayList<Integer>());

    for (int i = 0; i < list.size(); i++) {
        ArrayList<ArrayList<Integer>> current = new ArrayList<ArrayList<Integer>>();

        for (ArrayList<Integer> l : result) {
            for (int j = 0; j < l.size()+1; j++) {
                l.add(j, list.get(i));

                ArrayList<Integer> temp = new ArrayList<Integer>(l);
                current.add(temp);

                l.remove(j);
            }
        }

        result = new ArrayList<ArrayList<Integer>>(current);
    }

    return result;

}

私有静态ArrayList置换（ArrayList列表）{
ArrayList结果=新建ArrayList（）；
添加（新的ArrayList（））；
对于（int i=0；i

给你，伙计：

main:
ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    ArrayList<ArrayList<Integer>> ans = permutate(list, null, 0);


private static ArrayList<ArrayList<Integer>> permutate(
        ArrayList<Integer> list, ArrayList<Integer> curlist, int cur) {
    if (cur == 0) {
        ArrayList<ArrayList<Integer>> totalAns = new ArrayList<ArrayList<Integer>>();
        for (Iterator<Integer> iterator = list.iterator(); iterator
                .hasNext();) {
            Integer integer = (Integer) iterator.next();
            ArrayList<Integer> tmp3 = new ArrayList<Integer>();
            tmp3.add(integer);
            ArrayList<ArrayList<Integer>> firstAns = permutate(list, tmp3,
                    cur + 1);
            for (Iterator<ArrayList<Integer>> iterator2 = firstAns
                    .iterator(); iterator2.hasNext();) {
                ArrayList<Integer> arrayList = (ArrayList<Integer>) iterator2
                        .next();
                totalAns.add(arrayList);

            }
        }
        return totalAns;
    }
    if (cur == list.size()) {
        ArrayList<ArrayList<Integer>> tmp2 = new ArrayList<ArrayList<Integer>>();
        tmp2.add(curlist);
        return tmp2;
    }

    ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();
    for (int i = 0; i < list.size(); i++) {
        if (!curlist.contains(list.get(i))) {
            @SuppressWarnings("unchecked")
            ArrayList<Integer> tmp = (ArrayList<Integer>) curlist.clone();
            tmp.add(list.get(i));
            ArrayList<ArrayList<Integer>> recAns = permutate(list, tmp,
                    cur + 1);
            for (int k = 0; k < recAns.size(); k++) {
                ans.add(recAns.get(k));
            }
        }

    }
    return ans;
}

main：
ArrayList=新建ArrayList（）；
增加第（1）款；
增加（2）；
增加（3）；
ArrayList ans=permutate（列表，null，0）；
私有静态ArrayList置换(
ArrayList列表，ArrayList卷曲列表，int cur）{
如果（cur==0）{
ArrayList totalAns=新的ArrayList（）；
for（迭代器迭代器=list.Iterator（）；迭代器
.hasNext（）；）{
整数=（整数）迭代器。下一步（）；
ArrayList tmp3=新的ArrayList（）；
tmp3.add（整数）；
ArrayList firstAns=置换（列表，tmp3，
cur+1）；
for（迭代器迭代器2=第一个
.iterator（）；iterator2.hasNext（）；）{
ArrayList ArrayList=（ArrayList）迭代器2
.next（）；
totalAns.add（arrayList）；
}
}
返回全然数；
}
如果（cur==list.size（））{
ArrayList tmp2=新的ArrayList（）；
tmp2.add（卷发器）；
返回tmp2；
}
ArrayList ans=新的ArrayList（）；
对于（int i=0；i

为什么要将一个arraylist包装到另一个。。。？在任何情况下，像这样考虑，排列一个列表{a，b，c，d，…}可以通过选择一个随机元素，比如b，移除它，然后排列列表的其余部分来完成。所以结果={b}并集{列表其余部分的置换}。这是你的递归，我返回一个数组列表，一个数组列表，一个排列列表。看看这个：有一种设计递归方法的系统方法。首先，您假设在某个地方已经存在该方法的工作版本。然后你会问自己，你如何通过使用另一个先前存在的方法来编写你的方法，但前提是在你进行递归调用之前，你必须将问题简化为一个（稍微）小的问题。一旦你写了，你添加了一个停止条件，并再次检查结果方法，看看是否需要任何额外的调整。这就是答案，不要做已经存在的事情。你知道，虽然你回答问题很好，但我想至少能解释一下你在做什么。你在没有任何解释的情况下为他/她编写代码，这是在帮他/她的忙。此外，你在技术上没有回答这个问题：“有没有一种系统的方法将我的迭代解转换为递归解？”说“这是一个递归解”并没有严格地回答这个问题。正如我在上面对Mike的回答所评论的，从技术上讲，你没有回答“有没有一种系统的方法可以将我的迭代解决方案转换为递归的？”说“这是一个递归的解决方案”并不能严格地回答这个问题。此外，解释代码（以及你的思维过程）会使这更可能成为一个答案。

public static void main(String[] args) throws Exception {

    List<Integer> intList = new ArrayList<Integer>();
    intList.add(1);
    intList.add(2);
    intList.add(3);
    List<List<Integer>> myLists = listPermutations(intList);

    for (List<Integer> al : myLists) {
        String appender = "";
        for (Integer i : al) {
            System.out.print(appender + i);
            appender = " ";
        }
        System.out.println();
    }

}

1 2 3
2 1 3
2 3 1
1 3 2
3 1 2
3 2 1

main:
ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);
    ArrayList<ArrayList<Integer>> ans = permutate(list, null, 0);


private static ArrayList<ArrayList<Integer>> permutate(
        ArrayList<Integer> list, ArrayList<Integer> curlist, int cur) {
    if (cur == 0) {
        ArrayList<ArrayList<Integer>> totalAns = new ArrayList<ArrayList<Integer>>();
        for (Iterator<Integer> iterator = list.iterator(); iterator
                .hasNext();) {
            Integer integer = (Integer) iterator.next();
            ArrayList<Integer> tmp3 = new ArrayList<Integer>();
            tmp3.add(integer);
            ArrayList<ArrayList<Integer>> firstAns = permutate(list, tmp3,
                    cur + 1);
            for (Iterator<ArrayList<Integer>> iterator2 = firstAns
                    .iterator(); iterator2.hasNext();) {
                ArrayList<Integer> arrayList = (ArrayList<Integer>) iterator2
                        .next();
                totalAns.add(arrayList);

            }
        }
        return totalAns;
    }
    if (cur == list.size()) {
        ArrayList<ArrayList<Integer>> tmp2 = new ArrayList<ArrayList<Integer>>();
        tmp2.add(curlist);
        return tmp2;
    }

    ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>();
    for (int i = 0; i < list.size(); i++) {
        if (!curlist.contains(list.get(i))) {
            @SuppressWarnings("unchecked")
            ArrayList<Integer> tmp = (ArrayList<Integer>) curlist.clone();
            tmp.add(list.get(i));
            ArrayList<ArrayList<Integer>> recAns = permutate(list, tmp,
                    cur + 1);
            for (int k = 0; k < recAns.size(); k++) {
                ans.add(recAns.get(k));
            }
        }

    }
    return ans;
}