给定一个数组，如果可以递归地将其拆分为两个相等的组，则返回true

Question

方法名称：

public static boolean equalSplit (int[] a) 

如果可以将数组拆分为两个，且值的总和相等，则返回true，例如：

{-3,5,12,14,-9,13} // returns true -3+5+14 = 12+(-9)+13
{-3,5,-12,14,-9,13}; //return false,you can split it to two groups but the groups won`t be equal 3+5+14+(-12)=-9+13 
{-3,5,12,14,-9}; // false because can`t split the array to two

不允许更改数组顺序，只允许递归不允许循环，私有方法也可以，只要是递归的。

我写的内容（代码不完整）：

public class Rec
{
    // private method to find total sum of an array.
    static int findSum(int A[], int N)
    {
        if (N <= 0)
            return 0;
        return (findSum(A, N - 1) + A[N - 1]);
    }    

    
    //
    public static boolean equalSplit (int[] a)
    {
      return(equalSplit(a,0,0));   
    }
    
    // override
    private static boolean equalSplit (int[] a,int sum,int i) 
    {
        int totalSum = findSum(a,a.length); // total sum of the given array.
        if(i > a.length) // run until reach the end of the array.
            return false;
        if(totalSum - sum == sum) // if subtracting the recursive sum from total sum gives equal number return true
            return true;
   
        int take = equalSplit(a,sum + a[i] , i+1); // boolean cannot be convereted to int
    }    
}

我想做的是：我使用一个私有方法来求整个数组的和，然后从总和中减去。主方法中假设逐步求和数组的和。我的问题是这个方法是布尔的，我不知道如何递归地使用布尔方法来完成它。

我的问题：你能告诉我结构是否好吗？我该怎么做？

Answer 1

这是一个不使用循环、不改变顺序的解决方案，

static int[] arrA, arrB;
    public static boolean equalSplit(int[] arr) {
        //Step 1
        if (arr.length % 2 == 0) {
            int sumA = 0, sumB = 0; // Two int variables to store the value of sum.

            // Initializing the two new arrays with equal length.
            arrA = new int[arr.length / 2]; 
            arrB = new int[arr.length / 2];

            // Copying the elements from the given array to the new arrays.
            arrA = createArray(arrA, 0, arr, 0);
            arrB = createArray(arrB, 0, arr, arr.length / 2);

            //Calculating and storing the sum in the variables.
            sumA = arraySum(arrA, arrA.length);
            sumB = arraySum(arrB, arrB.length);

            return sumA == sumB; // Checking the codition

        } else {
            return false;
        }
    }

    private static int[] createArray(int[] arr, int index, int[] copyFrom, int copyFromIndex) {
        if(index == arr.length) return arr;
        arr[index] = copyFrom[copyFromIndex];
        index++;
        copyFromIndex++;
        return createArray(arr, index, copyFrom, copyFromIndex);
    }

    private static int arraySum(int[] arr, int N) {
        if (N <= 0) return 0;
        return (arraySum(arr, N - 1) + arr[N - 1]);
    } 

我对这个问题的看法是，

第一步-

步骤2-

第三步-

步骤4-

说明：

>

创建两个新的整数数组，只有当给定的数组可以被分成两个相等的部分时，才会被填充。这里是arrA和arrB。

检查给定数组的长度是否可以被2除，并且是否有0个余数，因为这可以回答“此数组可以被分成两个相等的部分吗？”。这个答案中的代码是arr.length%2==0。如果给定数组仅满足此条件，则将执行下面给出的步骤，否则将返回false。

初始化两个整数变量以存储两个等分数组的Sum值。

初始化两个新创建的数组，数组长度为给定数组的一半，即arr.length/2。

然后将给定数组元素的前半部分复制到第一个新初始化的数组中，然后将第二部分复制到第二个数组中。为了实现这个createArray（int[]arr，int index，int[]copyFrom，int copyFromIndex）方法被使用。arr是传递应复制到的数组的参数，索引应为0，因为它用作新创建数组的索引，copyFrom是包含所有元素的给定数组的参数，copyFromIndex用于开始从给定索引复制元素。

然后使用递归函数计算总和，并将其存储在之前创建的单独变量中。这里使用的函数是arraySum（int[]arr， int N）。

返回两个总和变量是否相等。