Java 创建所有置换数组的置换算法

我正在尝试写一个叫做排列的方法。基本上，我希望它接受一个整数，然后返回从0到x-1的所有数字排列。我意识到这应该返回一个数组。然而，我正在努力实现这一点。有人能帮我更好地思考这个问题吗？我正在用java编写代码。我意识到这可能是一个递归问题，但除此之外，我感到无所适从

我考虑使用两种方法，一种是接受整数并从0-x-1生成第一个数组。然后是另一个接受数组和某个整数“start”的方法。这样，索引开始处的整数不会更改，但会与其他数字交换。这将位于for循环的内部，因此“开始”位置将在整个阵列中改变。关于这一点，我得到的唯一提示是，我的for循环将递归调用该方法。然而，我在思考如何实际实现这一点以及交换算法时遇到了困难

---

有人能告诉我，我的想法是否正确，他们是否有任何想法或提示给我？我没有代码可以分享，因为我一直在白板上记录我的大部分想法

如果我理解正确，这就是你想要的smt

public class MyClass_3928{

    static List<String> listOfAllArrays = new ArrayList<>();

    public static void calculate(int[] list, int n) {
        if (n == 1) {
            listOfAllArrays.add(Arrays.toString(list));
        } else {
            for (int i = 0; i < n; i++) {
                calculate(list, n - 1);

                int j = (n % 2 == 0) ? i : 0;

                int t = list[n - 1];
                list[n - 1] = list[j];
                list[j] = t;
            }
        }

    }

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.print("How many numbers would you like to permute?");
        int numbers = Integer.valueOf(scanner.nextLine());
        int[] numbersArray = new int[numbers-1];
        System.out.println("Those numbers are");
        for (int i = 0; i < numbers-1; i++) {
            numbersArray[i] = i+1;
        }

        calculate(numbersArray, numbersArray.length);

        for (int i = 0; i < listOfAllArrays.size(); i++) {
            System.out.println(listOfAllArrays.get(i));
        }

    }

公共类MyClass3928{
静态列表listofallarys=newarraylist（）；
公共静态无效计算（int[]列表，int n）{
如果（n==1）{
添加（Arrays.toString（list））；
}否则{
对于（int i=0；i

置换可以用一种典型的回溯算法来解决，在这种算法中，我们必须遍历状态空间中的所有可能性并努力掌握它的基本思想，而不是试图用自己的方式解决置换问题

基本上，为了找到一个置换，我们必须走n步（设置一位就是一步），在我们为每一步选择一位之后，我们有一个置换，所以我们有一个可能的解决方案（比如说，它是

1,2,3,4,5,6

）.之后，我们回溯到最后一位，注意，我们在第一个解决方案中选择了

5

，但我们可以有另一个选择

6

，之后，最后一位只有一个选择，即

5

。对于其他解决方案，我们继续回溯到最后第三位、最后第四位…，依此类推。这就是原因关于回溯为什么被命名

您可以将回溯与DFS或二叉树上的traveral算法进行比较。它们在许多地方非常相似。

下面是我对这个问题的解决方案，其中结果是一个arrayList，并根据

1…n

而不是

0…n-1

给出排列，但其中的思想完全相同

class Solution {
public List<List<Integer>> permute(int[] nums) {
    List<List<Integer>> permutations=new ArrayList();
    backtrack(permutations,new ArrayList<Integer>(),nums);
    return permutations;
}

private void backtrack(List<List<Integer>> permutations,List<Integer> tempList,int[] nums){
    if(tempList.size()==nums.length){
        permutations.add(new ArrayList<Integer>(tempList));
        return;
    }

    for(int i=0;i<nums.length;i++){
        if(tempList.contains(nums[i])){
            continue;
        }

        tempList.add(nums[i]);    
        backtrack(permutations,tempList,nums);
        tempList.remove(tempList.size()-1);
    }

}

类解决方案{
公共列表排列（int[]nums）{
列表置换=新的ArrayList（）；
回溯（置换、新ArrayList（）、nums）；
返回置换；
}
私有无效回溯（列表排列、列表模板、int[]nums）{
if（templast.size（）=nums.length）{
添加（新的ArrayList（tempList））；
返回；
}
对于（int i=0；我在这里看到：@maxihatop，但OP想使用递归来实现它。@user202729 OP不想，他认为他可能应该。这是错误的；迭代解决方案可能在各个方面都更好。有一个经典的迭代算法（例如在Knuth的TAOCP中找到，但要旧得多）。请参阅