如何在java中打印出X个排列？

Question

我编写的代码获取数组的元素，并遍历数组以给出所有排列。但我需要它只显示一定数量的排列：

最后的代码是只给出9个元素的6个排列（换句话说，打印总362880个输出中的前60480个排列）。为简单起见，我正在使用数组中的4个元素，并且我得到了所有24个排列以打印出来。但是我需要代码可以用于任意数量的排列。例如，如果我需要它打印出1-perMutation，代码应该打印前4个排列——ABCD、ABDC、ACBD和ACDB。我不确定如何解决这个问题。

public static void main(String[] args) {
    // TODO Auto-generated method stub


    String[] myArray = {"A","B","C", "D"};
    int size = myArray.length; 
    permutation(myArray, 0, size-1);

    // Calculate Permutations
    int n=size;
    int r=6; // subject to change
    int p = n - r;
    int total=1;
    int total2=1;
    int total3=0;

    for (int top=n; top>0; top--)
    {
        total *= top;
    }

    if ((n-r<0))
    {
     System.out.println("r value cannot be greater than array size");
     total3=0;
    }
    else 
    {
        for (int bot=1; bot<=p; bot++)
        {
            if (p==0) // should be -- else if (p==0) -- after correction
            {
                total2=1;
            }
            else
            {
                total2 *= bot;
            }
        }
        total3 = total/total2;
    }

    System.out.printf("%d permutations of %d elements = %d\n",r,n,total3);
    // end calculation

}
// end main

// print array
public static void prtArray(String[] myArray, int size)
{
    for(int i=0; i<size; i++)
    {
        System.out.printf("%s", myArray[i]);
    }
    System.out.println();
}

// swap elements    
public static void swap(String[] myArray, int i, int j) {
    String temp;
    temp = myArray[i];
    myArray[i]=myArray[j];
    myArray[j]=temp;
}

// permutation 
private static void permutation(String[] myArray, int b, int e)
{
    if (b == e)
        prtArray(myArray, e+1); // accounts for array of size 1
    else
    {
        for(int i = b; i <= e; i++)
        {

            swap(myArray, i, b);
            permutation(myArray, b+1, e);
            swap(myArray, i, b);

        }
    }
}
}

Answer 1

我假设您不希望元素在排列中重复。例如。

如果输入数组是{1,2,3,4}，则对于长度3：123、124等是有效的排列，但122或111不是。

为了避免拾取已经拾取的元素，我们需要在递归中传递一个＜code＞访问的＜code＞数组。

public class Main {
    // Maintain a global counter. After finding a permutation, increment this. 
    private static int count = 0;

    // pos is the current index, and K is the length of permutation you want to print, and N is the number of permutation you want to print.
    private static void printPermutations(int[] arr, int[] visited, int pos, int K, int N, String str) {

        // We have already found N number of permutations. We don't need anymore. So just return.
        if (count == N) {
            return;
        }

        if (pos == K) {
            System.out.println(str);
            count++; // we have found a valid permutation, increment counter.
            return;
        }

        for (int i = 0; i < arr.length; i++) {
            // Only recur if the ith element is not visited.
            if (visited[i] == 0) {
                // mark ith element as visited.
                visited[i] = 1;
                printPermutations(arr, visited, pos + 1, K, N, str + arr[i]);
                // unmark ith element as visited.
                visited[i] = 0;
            }
        }

    }


    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        int[] visited = {0, 0, 0, 0}; // same as size of input array.
        count = 0; // make sure to reset this counter everytime you call printPermutations.
        // let's print first 4 permutations of length 3.
        printPermutations(arr, visited, 0, 3, 4, "");
    }
}

产出:

对于N = 4和K = 3(即长度为3的前4个排列):

printPermutations(arr, visited, 0, 3, 4, "");

123
124
132
134

对于N=4和K=4（即长度为4的前4种排列）：

printPermutations(arr, visited, 0, 4, 4, "");

1234
1243
1324
1342