Java 数组子集不等和

我需要写一个函数，将一个数组分成两部分{4,5,2,1,3}，这样第一个数组中的和大于第二个数组中的和，但第一个数组的长度小于第二个数组的长度。它们的和的并集是总和，它们没有交集。所以，答案是{4,5}

import java.util.ArrayList;
import java.util.Stack;

public class DP2 {

    public static void main(String args[]) {
        int[] arr= {5,2,10,4,1,11};
        ArrayList<Integer> list=new ArrayList<>();
        //calculate sum
        int finalSum=0;
        /*
        for(int i: arr)
            finalSum+=arr[i];
            */
        int len=arr.length;
        int mid=(len)/2;
        System.out.println(mid);
        int sum=0;
        //initialize 2 pointers

        //will use a stack
        Stack<Integer> stack = new Stack<Integer>();

        int i=0,j=len-1;
        int max=Integer.MIN_VALUE;
        while(i < j ) {
            //int max=Math.max(arr[i], arr[j]);
        //  System.out.println(max);
            while(stack.size() < mid) {


                max=Math.max(arr[i], arr[j]);
                stack.push(max);
                //System.out.println(stack.size());
            //  System.out.println(stack.peek());
                i++;
                j--;
            }

        //  max=Math.max(arr[i], arr[j]);
            i++;
            j--;

            if(stack.size() < mid  && stack.peek() < max  ) {




                    stack.pop();
                    stack.push(max);


                }




        }


        while(!stack.isEmpty())
            System.out.println(stack.pop());




        }
    }

import java.util.ArrayList；
导入java.util.Stack；
公共类DP2{
公共静态void main（字符串参数[]）{
int[]arr={5,2,10,4,1,11}；
ArrayList=新建ArrayList（）；
//求和
int finalSum=0；
/*
用于（int i:arr）
finalSum+=arr[i]；
*/
int len=arr.length；
int mid=（len）/2；
系统输出打印项次（mid）；
整数和=0；
//初始化2个指针
//将使用堆栈
堆栈=新堆栈（）；
int i=0，j=len-1；
int max=整数的最小值；
而（i

---

它不会返回预期的答案。它并不像我编写的那样从堆栈中弹出。有人能帮我做错事吗。

从我所看到的情况来看，一切正常。唯一的问题是弹出操作以相反的顺序给出结果。我已在下面的代码中修复了该问题：

Integer[] result = new Integer[stack.size()];
for (int i1 = result.length - 1; i1 >= 0 && !stack.isEmpty(); i1--) {
    result[i1] = stack.pop();
}
System.out.println(Arrays.toString(result));

输出

[4,5]

按要求编辑：以下是您问题的完整解决方案：

/**
 * Convert an array of primitive numbers to Integer objects.
 */
private static Integer[] intToInteger(int[] array) {
    return Arrays.stream(array).boxed().toArray( Integer[]::new );
}

/**
 * Converts a primitive integer array to an ArrayList.
 */
private static ArrayList<Integer> intArrayTolist(int[] array) {
    return new ArrayList<>(Arrays.asList(intToInteger(array)));
}

public static void main(String[] args) {

    int[] arr0 = { 5, 2, 10, 4, 1, 11 };

    /* determine the size of the first array */
    float quotient = (float)arr0.length / 2;
    int mid = (int) Math.floor(quotient);

    int size = quotient != mid ? mid : mid - 1;

    /* Initialize arrays here */
    Integer[] arr1 = new Integer[size];
    Integer[] arr2 = new Integer[arr0.length - mid];

    List<Integer> list = intArrayTolist(arr0);

    /* Populate the first array with largest values
     * found within the main array
     */
    for (int i = 0; i < size; i++) {
        /*
         * Find out the largest value in the main array
         * and add that value to the first array
         */
        arr1[i] = java.util.Collections.max(list);
        list.remove(arr1[i]);
    }

    arr2 = list.toArray(arr2);
    int sum = Arrays.stream(arr0).sum();

    System.out.println("First array: " + Arrays.toString(arr1));
    System.out.println("Second array: " + Arrays.toString(arr2));
    System.out.println("Sum of all numbers: " + sum);
}

---

请注意，它可能不像我跳的那么优雅，但它完成了任务。我会看看我是否可以做一些进一步的清洁和优化，因为我觉得那里有很多冗余。这只是一个快速的模型，这样你就可以得到一些真正有效的东西。

我使用了递归。我就是这样做的：

@Test
public void stackoverflow() {
    int[] array = { 39, 2, 3, 40, 0, 0, 0 };
    System.out.println("index is " + method(array, 0));
}

String method(int[] array, int i) {
    if (i < array.length / 2 && sum(array, 0, i) > sum(array, i + 1, array.length - 1)) {
        return "the sub array goes from 0 to " + i;
    }
    else if (i >= array.length / 2 && sum(array, array.length - 1 - i + array.length / 2, array.length - 1) > sum(array, 0, array.length - i - 2 + array.length / 2)) {
        int index = array.length - 1 - i + array.length / 2;
        return "the sub array goes from " + index + " to " + (array.length - 1);
    }
    return method(array, i + 1);
}

int sum(int[] array, int i, int j) {
    int sum = 0;
    for (int k = i; k <= j; k++) {
        sum = sum + array[k];
    }
    return sum;
}

它将返回“4”。[4] 这个元素是：

{ 0, 0, 0, 0, 40, 1, 2, 3 }
               *

---

这里很清楚，如果索引>n/2，则子数组从索引变为n-1。如果不是，则子数组从0变为n/2。

但我想说的是，这应该返回最小长度子数组和最大和。如果我使用{1,4,6,7,9,11,10}，它应该返回{11,10}。我已经更新了答案，包含了你问题的完整解决方案。让我知道它是否对你有效，如果它还有什么需要做的。你有机会测试一下吗？

{ 0, 0, 0, 0, 40, 1, 2, 3 }

{ 0, 0, 0, 0, 40, 1, 2, 3 }
               *