Question

我正在尝试构建一个程序，该程序将采用int（{1,2,3}和一个长度值的数组并计算该数组的所有可能组合。

例如：

int[] arr= new char[] {0,1};
int[] tes  = new int[3];
possiblecomb(2, arr,tes,0);

这将输出：

但是当我尝试在for循环中调用possiblecomb时，我不断收到堆栈溢出错误

 import java.util.Arrays;

 public class Program {

public static void main(String[] args) {

    // Create an arr to work with
    int[] test = new int[] {0,1};
     int[] tes  = new int[3];
    // Find all possible combinations of this arr in the string size of 3
    possiblecomb(3, test,tes,0);
}

public static void possiblecomb(int maxLength, int[] nums, int[] curr,int end) {

    // If the current array has reached it's maximum length
    if(end == maxLength) {
        System.out.println(Arrays.toString(curr));

    // Else add each number from the numbs to new array and process these new arrays again
    } else {
        for(int i = 0; i < nums.length; i++) {
            int[] oldCurr = curr.clone();
            curr[end]= nums[i];
            possiblecomb(maxLength,nums,curr,end++);
            curr = oldCurr.clone();
        }
    }
}

}

Answer 1

尝试在for之外移动递归调用。

您正在使用for来复制内容。

你的结束变量最终会超过最大长度，而你的（==）比较不会成为阻碍。

以num.Length = 2且end为2：

为例

您将使用end = 3调用您的函数，它将在递归调用中停止并打印，然后，当i == 1时，您的结束将为4并且递归调用不会中断。

如果您想避免使用当前代码进行无限递归以便更好地使用输出进行调试，请设置中断条件

if (end>=maxLength)

Answer 2

正如@MichaelCMS所说，你永远不会停止递归，因此堆栈溢出。

如果您不介意使用Lists代替arrays，这是一个解决方案：

import java.util.*;

public class Program {
  private static List<List<Integer>> combinations(List<Integer> list, int maxLength) {
    return combinations(list, maxLength, new ArrayList(), new ArrayList());
  }

  private static List<List<Integer>> combinations(List<Integer> list, int length, List<Integer> current, List<List<Integer>> result) {
    if (length == 0) {
      List<List<Integer>> newResult =  new ArrayList<>(result);
      newResult.add(current);
      return newResult;
    }

    List<List<List<Integer>>> res3 = new ArrayList<>();
    for (Integer i : list) {
      List<Integer> newCurrent = new ArrayList<>(current);
      newCurrent.add(i);
      res3.add(combinations(list, length - 1, newCurrent, result));
    }

    List<List<Integer>> res2 = new ArrayList<>();
    for (List<List<Integer>> lst : res3) {
      res2.addAll(lst);
    }
    return res2;
  }

  public static void printCombinations(List<Integer> list, int maxLength) {
    List<List<Integer>> combs = combinations(list, maxLength);
    for (List<Integer> lst : combs) {
      String line = "";
      for (Integer i : lst) {
        line += i;
      }
      System.out.println(line);
    }
  }

  public static void main(String[] args) {
    List<Integer> l = Arrays.asList(0, 1);
    printCombinations(l, 2);
  }
}

这会给你：

Java计算给定int数组的所有可能组合

2 个答案: