-1

我对Java中的递归不是很熟悉。我正在尝试编写一种方法来计算整数数组的所有排列。我需要修改以下完美的工作方法，以便将它们插入到二维数组中，而不是打印以筛选数组的所有排列。所以该方法的输入是n个整数的数组，输出是一个n的二维数组！行和n列。我需要修改的程序是这样的：

public static void permute(int[] array, int k)
{
    for(int i=k; i<array.length; i++)
    {
        int temp;
        temp = array[i];
        array[i] = array[k];
        array[k] = temp;
        permute(array, k+1);
        int temp2;
        temp2 = array[i];
        array[i] = array[k];
        array[k] = temp2;
    }
    if (k == array.length-1)
    {
        Array.printValues(array);
    }
}

所以，我需要的是这样的：

public static int[][] permute(int[] array, int k)
{
    //code here
}

谢谢你。

4

4 回答 4

1

将它们放在一个列表中，然后从中取出一个数组。您可以直接使用 int[][] 但如果没有额外的重复，您不知道第一个维度值。

public static int[][] permuteToArray(int[] array, int k){
    ArrayList<int[]> arrL=new ArrayList<>();
    for(int i=k; i<array.length; i++)
    {
        int temp;
        temp = array[i];
        array[i] = array[k];
        array[k] = temp;
        permute(array, k+1, arrL);
        int temp2;
        temp2 = array[i];
        array[i] = array[k];
        array[k] = temp2;
    }
    if (k == array.length-1)
    {
        arrL.add(array);
    }
    return arrL.toArray(new int[][]);
}

更改permute(为：

public static void permute(int[] array, int k, ArrayList arrL) //raw type, I know
{
    for(int i=k; i<array.length; i++)
    {
        int temp;
        temp = array[i];
        array[i] = array[k];
        array[k] = temp;
        permute(array, k+1);
        int temp2;
        temp2 = array[i];
        array[i] = array[k];
        array[k] = temp2;
    }
    if (k == array.length-1)
    {
        arrL.add(array);
    }
}
于 2013-08-23T08:51:19.457 回答
0 
 public static void swap(int[] array, int i, int j) {
    int temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

public static void permute(int[] array, List<int[]> cache, int k)
{

    if (k == array.length-1)
    {
        cache.add(array.clone()); //use clone, or you will get the same int array
        return;
    }
    for(int i=k; i<array.length; i++)
    {
        swap(array, i,k);
        permute(array, cache, k+1);
        swap(array, i, k);
    }
}
于 2013-08-23T09:31:28.193 回答
0 
public static void _permute(ArrayList<ArrayList<Integer>> res, ArrayList<Integer> cur, int k, boolean[] status, int[] array)
{
  if (cur.size() == k) {
    res.add((ArrayList<Integer>)cur.clone());
    return;
  }
  for (int i = 0; i < k; i++)
  {
    if (status[i]) continue;
    cur.add(array[i]);
    status[i] = true;
    _permute(res, cur, k, status, array);
    status[i] = false;
    cur.remove(new Integer(array[i]));
  }
}

public static ArrayList<ArrayList<Integer>> permute(int[] array, int k)
{
  ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
  ArrayList<Integer> cur = new ArrayList<Integer>();
  boolean[] status = new boolean[k];
  for (int i = 0; i < k; i++) 
  {
    status[i] = false;
  } 
  _permute(res, cur, k, status, array);
  return res;
  //code here
 }

您可以在数组列表中获取数组的所有排列。我认为您可以自己从列表中提取数组。请注意，如果原始数组中有相同的数字，此函数可以删除重复。

于 2013-08-23T09:14:01.140 回答
0

我可以给你一个递归置换算法的例子。它基于 n 个元素的排列基于 n-1 个元素的排列这一事实。

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

class Permutation {

    public static void main(String[] args) {
        List<Object> input = new ArrayList<>();
        input.add(1);
        input.add(2);
        input.add(3);
        print(permutation(input));
    }

    public static void print(List<List<Object>> list) {
        for (List<Object> objects : list) {
            System.out.println(objects);
        }
    }

    public static List<List<Object>> permutation(List<Object> input) {
        if (input.isEmpty()) {
            throw new IllegalStateException();
        }
        // This is end condition for recursion
        if (input.size() == 1) {
            List<List<Object>> result = new ArrayList<>();
            result.add(input);
            return result;
        }
        return merge(input.get(0), permutation(input.subList(1, input.size())));
    }

    private static List<List<Object>> merge(Object o, List<List<Object>> input) {
        List<List<Object>> result = new ArrayList<>();
        int inputSize = input.get(0).size();
        for (int i = 0; i < inputSize + 1; i++) {
            for (List<Object> oneRow : input) {
                // copy the row and insert additional element
                List<Object> oneRowExpanded = new ArrayList<>();
                oneRowExpanded.addAll(oneRow);
                oneRowExpanded.add(i, o);
                result.add(oneRowExpanded);
            }
        }
        return result;
    }
}

这将打印以下内容：

[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[3, 1, 2]
[2, 3, 1]
[3, 2, 1]
于 2021-01-17T19:27:34.387 回答