Question

我正在寻找一种将数组分成两半的方法（中间数字不包括在内），直到最后创建的数组仅包含一个数字。中间数字恰好在中间（例如， [1,2,3,4,5] 是 3 ）或第二个数字的第一个数组的一半（对于 [1,2,3,4,5,6] 为 4 ）

假设我有一个数组：

[1,2,3,4,5,6,7,8,9,10]

我应该得到：

[1,2,3,4,5] [7,8,9,10]

[1,2] [4,5] [7,8] [10]

[2]    [5]   [8]

我尝试了递归，但是它总是只分割数组的一半

public int[][] divide(int[] values, int[][] split_values, int index) {
  int root_index = 0;
  if(values.length > 1) {
    if(values.length % 2 != 0) {
        root_index = (values.length - 1) / 2;
    }
    else {
        root_index = (int) ((values.length) / 2);
    }
    int[] left_value = new int[root_index-1];
    int[] right_value = new int[values.length - left_value.length - 1];
    for(int i = 0; i < values.length; i++) {
        if(i < left_value.length) {
            left_value[i] = values[i];
        }
        else {
            right_value[i] = values[i];
        }
    }

    split_values[index] = left_value;
    index++;
    split_values[index] = right_value;
    index++;
  }
  for(int[] value : split_values) {
        divide(value, split_values, index);
  }
  return split_values;
}

编辑：所以我做了一些更改，该函数现在接受参数

 int[] values, int[][] split_values, String used, int index
 ...
 if(values.length > 1) {
 ...
 used += "!" + Arrays.toString(values) + "!";
 }

     for(int[] value : split_values) {
    if(!used.contains("!" + Arrays.toString(value) + "!")) {
            divide(value, split_values, used, index);
    }        
}

现在的问题是，这是一个永无止境的循环。

Answer 1

也许这会有所帮助：

保留所有元素：

 public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
        splitTo(array);
    }

    static void splitTo(Integer[] source) {
        int length = source.length;
        if (length == 1) return;
        boolean odd = length % 2 != 0;
        int half1 = length / 2;
        int half2 = odd ? half1 + 1 : half1;
        Integer[] one = new Integer[half1];
        Integer[] two = new Integer[half2];
        int index = 0;
        for (Integer element : one) {
            one[index] = source[index];
            two[index] = source[half1 + index];
            index++;
        }
        if (odd) two[index] = source[half1 + index];
        Integer[][] integers = {one, two};
        System.out.println(Arrays.deepToString(integers));
        splitTo(one);
        splitTo(two);
    }

拒绝中间一个：


    public static void main(String[] args) {
        Integer[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
        splitTo(array);
    }

    static void splitTo(Integer[] source) {
        int length = source.length;
        if (length == 1) return;
        boolean odd = length % 2 != 0;
        int half = length / 2;
        Integer[] one = new Integer[half];
        Integer[] two = new Integer[half];
        int index = 0;
        for (Integer element : one) {
            one[index] = source[index];
            two[index] = odd ? source[half + index + 1] : source[half + index];
            index++;
        }
        Integer[][] integers = {one, two};
        System.out.println(Arrays.deepToString(integers));
        splitTo(one);
        splitTo(two);
    }

如果您研究MergeSort算法，将是一个好的实践 https://en.wikipedia.org/wiki/Merge_sort

将数组分成两半，四等分

1 个答案: