我是一个更新鲜的程序员，被困在的下面
我想要一个输入数组的方法，比如
[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o]
并且在输出中返回低于序列，(即找到中间并添加到阵列(
[h, d, l, b, j, f, n, c, i, e, k, g, m, a, o]
使用迭代深化方法：
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);
}
}
}
但它的输出是：
[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]
假设i/p数组是包含{a,b,c......m,n,o}的array1。如果您希望您的输出数组存储中间元素，请创建另一个数组array2，并将array1的中间元素存储到array2中，然后从array1中删除中间元素，并继续上述过程，直到array1变为空。
您可以按照的任何过程从array1中删除元素
array = ArrayUtils.removeElement(array, element) //element is middle element of `array1` in your case
也可以使用for循环作为
for (int i = 0; i < array1.length; i++) {
// Delete Function
if (pos == i) { //pos is nothing but middle element
for (int j = i + 1; i < array1.length - 1; j++) {
array1[i] = array[j];
i++;
}
}
}
所以你要做的是玩"想想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，…
看看你是否能找出原因，以及如何修复它。