确定一个数字数组是否可以分为两个数组，每个数组保存相同的数字和

下面的代码用于确定一个数字数组是否可以分为两个数组，每个数组保存相同的数字之和。 例如：{1, 3 ,2, 6} 可以分为 {6} 和 {1,2,3}，因此返回 true 而 {1,5,7} 不能分为两个平衡数组，因此返回 false

public boolean canBalance(int[] nums) {
    for (int i = 0; i < nums.length; i++) { 
       int sum = 0;
       for (int j = 0; j < i; j++) sum += nums[j];
       for (int j = i; j < nums.length; j++) sum -= nums[j];
       if (sum == 0) return true;    
    }    
    return false;
}

这是codingbat练习的公认答案，我特别不理解这篇文章：

for (int j = 0; j < i; j++) sum += nums[j];
for (int j = i; j < nums.length; j++) sum -= nums[j];

迭代不是通常以 { 开头并以 } 结尾吗？ 如果 sum == 0 为什么可以平衡呢？ 我尝试用 {1,3,2,6} 数组将其记在纸上，总和为 26，返回 false，很明显 {1,3,2,6} 应该返回 true。

我想我误读了代码，但我不知道是哪一个。或者也许该算法是错误的，但它在codingbat中被接受了

两个 for 循环用于权衡数组的两个部分，以找到阵列平衡点一个数组的。

可以这样想：

你有一个空的天平秤，在外部 for 循环的第一次迭代中，i 为零。

来到第一个for循环，这里j为0，i为0i < j是假的，因此它不会进入第一个 for 循环，而是进入第二个 for 循环并从总和中减去所有数字。

从外部 for 循环的第二次迭代开始，它开始进入第一个 for 循环并且 开始将数组的元素一一相加到总和中。

在图片中，就像从一个空的天平秤开始，将所有元素添加到第二个秤中，然后将一个元素移动到第一个秤上，如下所示：

最后如果和为零，那么数组就可以平衡了，所以返回true。如果总和不为 0，则不平衡。

中的值通过如下循环进行平衡：

当 i 为 0 时外层 for 循环的迭代
循环2 -> i(0) j(0) 减1，和为-1
循环2 -> i(0) j(1) 减3，总和为-4
循环2 -> i(0) j(2) 减2，总和为-6
循环2 -> i(0) j(3) 减6，总和为-12

当 i 为 1 时外层 for 循环的迭代
循环1 -> i(1) j(0) 加1，和为1
循环 2 -> i(1) j(1) 减去 3，总和为 -2
循环 2 -> i(1) j(2) 减去 2，总和为 -4
循环2 -> i(1) j(3) 减6，总和为-10

当 i 为 2 时外层 for 循环的迭代
循环1 -> i(2) j(0) 加1，和为1
循环 1 -> i(2) j(1) 加 3，总和为 4
循环2 -> i(2) j(2) 减2，总和为2
循环2 -> i(2) j(3) 减6，总和为-4

当 i 为 3 时外层 for 循环的迭代
循环1 -> i(3) j(0) 加1，和为1
循环 1 -> i(3) j(1) 加 3，总和为 4
循环 1 -> i(3) j(2) 加 2，总和为 6
循环2 -> i(3) j(3) 减6，和为0

最终结果为真，因此数组可以平衡

Code:

public class Test {

    public static void main(String[] args) {
        int[] test = { 1, 3, 2, 6 };
        System.out.println("\nFinal result is "+canBalance(test));
    }

    public static boolean canBalance(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            System.out.println("\nIteration of outer for loop when i is " + i);
            int sum = 0;
            for (int j = 0; j < i; j++){
                sum += nums[j];
                System.out.println("Loop 1 -> i(" +i + ") j("+j + ") Add "+nums[j] + ", sum is "+sum+"       ");
            }
            for (int j = i; j < nums.length; j++){
                sum -= nums[j];
                System.out.println("Loop 2 -> i(" +i + ") j("+j + ") Subtract "+nums[j] + ", sum is "+sum+"       ");
            }
            if (sum == 0)
                return true;
        }
        return false;
    }
}

如果您想允许在数组元素之间进行洗牌，您可以使用递归，如下所示（注释是不言自明的）

public class Test {

    public static void main(String[] args) {
        int[] original = { 10, 2, 24, 32 };
        System.out.println(canDivideArray(original));
    }

    private static boolean canDivideArray(int[] originalArray) {
        int total = 0;

        for (int number : originalArray) {
            total += number;
        }

        // check if sum == 2x for any value of x
        if (total % 2 != 0) {
            return false;
        } else {
            // sum of each half array should be x
            total /= 2;
        }
        return isTotal(originalArray, originalArray.length, total);
    }

    private static boolean isTotal(int array[], int n, int total) {
        // successful termination condition
        if (total == 0) {
            return true;
        }
        
        // unsuccessful termination when elements have finished but total is not reached
        if (n == 0 && total != 0){
            return false;
        }

        // When last element is greater than total
        if (array[n - 1] > total)
            return isTotal(array, n - 1, total);

        //check if total can be obtained excluding the last element or including the last element 
        return isTotal(array, n - 1, total - array[n - 1]) || isTotal(array, n - 1, total); 
    }

}