Java 通过选择中间元素创建序列

我是一个新手程序员，我被困在下面

我想要一个接受数组输入的方法

[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o]

并在输出中返回以下顺序， i、 e.找到中间位置并添加到数组中

[h, d, l, b, j, f, n, c, i, e, k, g, m, a, o]

假设i/p数组是包含{a，b，c……m，n，o}的数组1。如果希望输出数组存储中间元素，请创建另一个数组array2并将array1的中间元素存储到array2中，然后从array1中删除中间元素并继续上述过程，直到array1变为空

您可以按照以下任何过程从阵列1中删除元素

array = ArrayUtils.removeElement(array, element) //element is middle element of `array1` in your case

也可以使用for循环作为

---

所以你要做的就是玩“想一个介于1和100之间的数字”的游戏。在计算机科学中，我们称之为分治算法。在本科文凭中，它是最重要、最有用的东西之一

那么这个游戏是如何运作的：

首先你选50个。然后，如果目标数字大于50，则选择75。如果小于75，则选择62或63

这是一个二元搜索——因为在每一点上，你有两个选择，四个——更高/更低/我们找到了它/它不在树中

因此，我们可以在大约7次猜测的自然对数100中找到100中的目标数，这对于N的大值是一个巨大的速度提升

所以你真正想做的是：

[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o]

把它变成这样：

[                     h                     ]
[         d,                      l,        ]
[   b           f           j,          n,  ]
[a,    c,    e,    g,    i,    k,    m,    o]

然后，您从图顶部的“根”处向下移动树

要递归地执行此操作，请使用如下伪算法：

 array pseudoRearrangeArray(arrayToRearrange) {
      return new array made up of:
          middle number
          +
          pseudoRearrangeArray(everything to the left of middle number)
          +
          pseudoRearrangeArray(everything to the right of middle number)
  }

当然这是错误的，因为它会输出[h，d，b，a，c

---

看看你是否能找出原因，以及如何修复它。

使用迭代深化方法：

public static void main(String[] args) {
    String[] input = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k",
        "l", "m", "n", "o"};
    String[] output = resequence(input);
    System.out.println(Arrays.asList(output));
}

private static String[] resequence(String[] input) {
    List<String> output = new ArrayList<>();
    for (int depth = 0; output.size() != input.length; ++depth) {
        iteration(input, 0, input.length, depth, 0, output);
    }
    return output.toArray(new String[output.size()]);
}

private static void iteration(String[] input, int min, int max,
        int target, int depth, List<String> output) {
    if (min < max) {
        int middle = (min+max)/2;
        if (target == depth) {
            output.add(input[middle]);
        } else {
            iteration(input, min, middle, target, depth+1, output);
            iteration(input, middle+1, max, target, depth+1, output);
        }
    }
}

更新

采用广度优先的方法：

static class Interval {
    private final int min;
    private final int max;

    Interval(int min, int max) {
        this.min = min;
        this.max = max;
    }
}

private static String[] resequence(String[] input) {
    List<String> output = new ArrayList<>();
    if (input.length > 0) {
        List<Interval> queue = new ArrayList<>();
        queue.add(new Interval(0, input.length));
        while (!queue.isEmpty()) {
            Interval ival = queue.remove(0);
            int middle = (ival.min+ival.max)/2;
            output.add(input[middle]);
            if (middle > ival.min) {
                queue.add(new Interval(ival.min, middle));
            }
            if (middle+1 < ival.max) {
                queue.add(new Interval(middle+1, ival.max));
            }
        }
    }
    return output.toArray(new String[output.size()]);
}

---

你尝试了什么？我尝试了两个递归函数，但没有得到我想要的want@SpectraTesting是的，我想你可以用递归function@Spectra测试——更重要的是，在帮助有明显家庭作业问题的人时，存在着根深蒂固的文化偏见。哦，他在做一棵二叉树，我现在明白了。非常感谢对于你的回答，这对我很有帮助。谢谢你宝贵的回答，实际上它返回的是预排序序列，我想要像平衡BST这样的序列：

[h, d, l, b, f, j, n, a, c, e, g, i, k, m, o]

static class Interval {
    private final int min;
    private final int max;

    Interval(int min, int max) {
        this.min = min;
        this.max = max;
    }
}

private static String[] resequence(String[] input) {
    List<String> output = new ArrayList<>();
    if (input.length > 0) {
        List<Interval> queue = new ArrayList<>();
        queue.add(new Interval(0, input.length));
        while (!queue.isEmpty()) {
            Interval ival = queue.remove(0);
            int middle = (ival.min+ival.max)/2;
            output.add(input[middle]);
            if (middle > ival.min) {
                queue.add(new Interval(ival.min, middle));
            }
            if (middle+1 < ival.max) {
                queue.add(new Interval(middle+1, ival.max));
            }
        }
    }
    return output.toArray(new String[output.size()]);
}

[h, d, l, b, f, j, n, a, c, e, g, i, k, m, o]