Java 这个程序应该是递归的，给我一个整数数组的所有可能的和

但是当我的数组大小超过2时，我会得到重复的答案

 public ArrayList sum(int[]array, int arrayIndex, int newArrayIndex){

   if (arrayIndex<array.length){
       if (newArrayIndex<pow(2,arrayIndex)){
         if(newarray.isEmpty()){
           newarray.add(0);
         }
       newarray.add(newarray.get(newArrayIndex)+array[arrayIndex]);
       sum(array,arrayIndex,newArrayIndex+1);
       sum(array,arrayIndex+1,newArrayIndex-newArrayIndex);
       }
   }
   return newarray;

---

有人能告诉我代码有什么问题吗？

对于您添加的每个元素，您都将进入下一个

arrayIndex

您应该在每次查看整个新阵列时执行一次

以下是您的程序，只需进行少量更改即可使其独立运行并按您所需的方式工作：

import java.util.*;
import static java.lang.Math.pow;

class NumbersAddition {
  ArrayList<Integer> newarray = new ArrayList<Integer>();
  NumbersAddition(Object unnecessary) {}

  public ArrayList sum(int[]array, int arrayIndex, int newArrayIndex){
     if (arrayIndex<array.length){
       if (newArrayIndex<pow(2,arrayIndex)){
         if(newarray.isEmpty()){
           newarray.add(0);
         }
         newarray.add(newarray.get(newArrayIndex)+array[arrayIndex]);
         sum(array,arrayIndex,newArrayIndex+1);
       } else { 
         // Just do this when newArrayIndex has reached the end:
         sum(array,arrayIndex+1,newArrayIndex-newArrayIndex);
       }
     }
     return newarray;
  }

  public static void main(String[] args) {
     int[] numarray ={1,2,3};
     NumbersAddition num = new NumbersAddition(numarray);
     num.sum(numarray,0,0);
     System.out.println(num.newarray);
  }
}

import java.util.*；
导入静态java.lang.Math.pow；
类号加法{
ArrayList newarray=新ArrayList（）；
数字相加（不需要对象）{}
公共ArrayList和（int[]数组，int arrayIndex，int newArrayIndex）{
if（arrayIndex只有当第二个条件（
newArrayIndex
）不满足时，才会发生第二个
和

提示：


不要总是检查列表是否为空，只需在初始化时添加0即可
您事先知道新数组所需的大小。您可以使用长度
Math.pow（2，array.length）
创建一个数组，并将元素添加到位置
pow（2，arrayIndex）+newArrayIndex
。这比反复调用
add
更有效

编辑：我使用数组和其他方法实现了一个隐藏初始化细节的方法：

private static void sumAux(int[] array, int i, int[] powerSet, int j)
{
    if (i < array.length)
    {
        int pow = (int) Math.pow(2, i);
        if(j < pow)
        {
            powerSet[pow + j] = powerSet[j] + array[i];
            sumAux(array, i, powerSet, j + 1);
        }
        else
        {
            sumAux(array, i + 1, powerSet, 0);
        }
    }
}

public static int[] sum(int[] array)
{
    int[] powerSet = new int[(int)Math.pow(2, array.length)];
    sumAux(array, 0, powerSet, 0);
    return powerSet;
}

public static void main(String[] args)
{
    int[] array = {2, 3, 7, 13};
    int[] powerSet = sum(array);
    for (int i : powerSet)
    {
        System.out.print(i + " ");
    }
}

private static void sumax（int[]数组，int i，int[]功率集，int j）
{
if（i
为什么要再次将数组传递给构造函数和方法？非常感谢。我现在刚开始使用递归，这有点困难。我还将尝试使用您建议的更规范的递归解决方案。
private static void sumAux(int[] array, int i, int[] powerSet, int j)
{
    if (i < array.length)
    {
        int pow = (int) Math.pow(2, i);
        if(j < pow)
        {
            powerSet[pow + j] = powerSet[j] + array[i];
            sumAux(array, i, powerSet, j + 1);
        }
        else
        {
            sumAux(array, i + 1, powerSet, 0);
        }
    }
}

public static int[] sum(int[] array)
{
    int[] powerSet = new int[(int)Math.pow(2, array.length)];
    sumAux(array, 0, powerSet, 0);
    return powerSet;
}

public static void main(String[] args)
{
    int[] array = {2, 3, 7, 13};
    int[] powerSet = sum(array);
    for (int i : powerSet)
    {
        System.out.print(i + " ");
    }
}