Question

我正在研究必须显示数组长度的可能排列的任务。我尝试了一些技巧，但仍然给出了许多输出的列表，最后我的项目崩溃了。

我已经进行了数学尝试，得到的答案是“ 39916800”。

例如：对于输入数组[3,2,1,4,6]，总共有5个！ = 120可能。

问题是：

给出int [] a = [3，10，4，6，1，1，8，5，9，0，11，7，2]。

您必须多久一次自己整理一次，直到再次得到一次（这就是a的程度）？

示例：[0,2,1]的度为2，因为置换（[0,2,1]，[0,2,1]）= [0,1,2]并置换（[0 ，1，2]，[0,2,1]）= [0,2,1]。

答案应为8位数字。

这是我的代码：

public class Permute{
static void permute(java.util.List<Integer> arr, int k){
    for(int i = k; i < arr.size(); i++){
        java.util.Collections.swap(arr, i, k);
        permute(arr, k+1);
        java.util.Collections.swap(arr, k, i);
    }
    if (k == arr.size() -1){
        System.out.println(java.util.Arrays.toString(arr.toArray()));
    }
}
public static void main(String[] args){
    Permute.permute(java.util.Arrays.asList(3,4,6,2,1), 0);
}

}

Answer 1

看下面的例子：

public class Main {
    static int[] requestedNumbs = {3,4,6,2,1};


public static List<List<Integer>> permuteUnique(int[] nums, int index) {
        List<List<Integer>> newList = new LinkedList<>();
        if (index == nums.length - 1) {
            List<Integer> newPermute = new LinkedList<>();
            newPermute.add(nums[index]);
            newList.add(newPermute);
        } else {
            List<List<Integer>> oldList = permuteUnique(nums, index + 1);
            for (List<Integer> permute : oldList) {
                int permuteSize = permute.size();
                int i = 0;
                for (; i < permuteSize; i++) {
                    List<Integer> newPermute = new LinkedList<>();
                    newPermute.addAll(permute.subList(0, i));
                    newPermute.add(nums[index]);
                    newPermute.addAll(permute.subList(i, permuteSize));
                    newList.add(newPermute);
                    if (permute.get(i) == nums[index]) {
                        break;
                    }
                }
                if (i == permuteSize) {
                    List<Integer> newPermute = new LinkedList<>();
                    newPermute.addAll(permute.subList(0, permuteSize));
                    newPermute.add(nums[index]);
                    newList.add(newPermute);
                }
            }
        }
        return newList;
    }

    public static void main(String[] args) {
       List<List<Integer>> list = permuteUnique(requestedNumbs,0);
       System.out.println("Size of a list: " + list.size());
       System.out.println(list);
    }
}

Answer 2

如果您的任务只是计算给定数组的可能排列的数量，则无需实际进行并输出这些排列。请注意，数字呈指数增长。取而代之的是，您可以通过数学方式计算该数字。只是做n！在一个简单的for循环中。

如果真的只有唯一整数：

public int permutations(int[] numbers){
  int result = 1;
  for(int i=2; i<=numbers.size(); i++){
    result*=i;
  }
  return result;
}

如何在Java中打印数组长度的可能排列

2 个答案: