Question

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

migrate

}

例如

 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;

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

Answer 1

对于您添加的每个元素，您将继续前一个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);
  }
}

顺便说一句，这段代码是两个嵌套for循环的尾递归重写。

更规范的递归解决方案是根据sums(array, length)定义sums(array, length-1)，sums(array, 0) = {0}作为基本情况。

Answer 2

只有当您的第二个条件（sum）不满足时，您的第二个newArrayIndex < pow(2, arrayIndex)才会发生。

<强>提示：

而不是总是检查您的列表是否为空，只需在初始化时添加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 + " ");
    }
}

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

2 个答案: