Question

我编写的代码采用数组的元素，并遍历数组以提供所有排列。但是我需要它仅显示一定数量的排列：

最后的代码是仅给出9个元素的6个排列（换句话说，打印总362880个输出中的前60480个排列）。为简单起见，我正在处理数组中的4个元素，并获得了所有24种排列以进行打印。但是我需要代码来处理任意数量的排列。例如，如果我需要它打印出1个排列，则代码应打印出前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

以下是五分之三的完整解决方案：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static java.util.stream.Collectors.toList;

public class Permutations {

  public static void main(String[] args) {
    String[] myArray = {"A", "B", "C", "D", "E"};
    List<String> list = Arrays.asList(myArray);

    List<List<String>> perms = makePerms(list, 3);
    perms.forEach(Permutations::printPerm);
    System.out.println("Size = " + perms.size());
}

  private static List<List<String>> makePerms(List<String> list, int count) {
    if (count == 1) {
      return list.stream().map(Arrays::asList).collect(toList());
    }
    return list.stream()
          .flatMap(e -> makePerms(remove(list, e), count - 1).stream()
                .map(l -> add(l, e)))
          .collect(toList());
  }

  private static <T> List<T> remove(List<T> list, T elem) {
    List<T> newList = new ArrayList<>(list);
    newList.remove(elem);
    return newList;
  }

  private static <T> List<T> add(List<T> list, T elem) {
    List<T> newList = new ArrayList<>(list);
    newList.add(elem);
    return newList;
  }

  private static void printPerm(List<String> perm) {
    perm.forEach(System.out::print);
    System.out.println();
  }
}

Answer 2

问题出在交换上。您的交换不交换数组中的元素。因为它获取两个字符串并交换它们，但它没有更改数组内部的值。修正您的交换问题，一切都会好起来的。

Answer 3

mine非常类似于Donat。接受一个元素并返回其余元素的len-1个排列。

public class Permuter {

public static void main(String[] args) {
    List<String> source = asList("A", "B", "C", "D");
    List<String> permutations = returnPermutations(source, 3, 0);
    permutations.forEach(s -> System.out.println(s));
}

private static List<String> returnPermutations(List<String> source, int choose, int len) {
    List<String> result = new ArrayList<>();

    if (len + 1 == choose) {
        return source;
    } else {
        for (String s : source) {
            List<String> tail = new ArrayList<>(source);
            tail.remove(s);
            result.addAll(returnPermutations(tail, choose, len+1).stream().map(ts -> s + ts)
                    .collect(Collectors.toList()));
        }
        return result;
    }
}

}

打印特定数量的排列（java）

3 个答案: