Question

我正在创建一个方法，使用一个参数来左移和右移数组中的字符，该参数指示要移位多少次。它必须在20毫秒内完成，所以我尝试了递归。

//在数组中切换位置的方法

public static void bytt(char[] c, int i, int j){
    char temp = c[i];
    c[i] = c[j];
    c[j] = temp;
}

//此方法向左移动

public static char rotasjon1(char[] a, int i){
    if(i > 0){
        bytt(a,i,i-1);
        return rotasjon1(a,i-1);
    }
    else
        return ' ';
}

//此方法向右移动

public static char reverseRotasjon(char[] a, int i){
    if(i < a.length-1){
        bytt(a,i,i+1);
        return reverseRotasjon(a,i+1);
    }
    else
        return ' ';
}

//此方法根据参数

决定使用右移或左移

public static void rotasjon(final char[] a, int k){
    if(a.length == 1 || a.length == 0){
        return;
    }
    if(k >= 0){
        for(int i = 0; i< k; i++){
            char temp = a[a.length-1];
            rotasjon1(a,a.length-1);
            a[0] = temp;
        }
    }

    if(k < 0){
        for(int i = k; i< 0; i++) {
            char temp = a[0];
            reverseRotasjon(a, 0);
            a[a.length - 1] = temp;
        }
    }
}

//所有这些都适用于此数组

char[] d = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
    char[] d0 = {'G', 'H', 'I', 'J', 'A', 'B', 'C', 'D', 'E', 'F'};

    Oblig1.rotasjon(d, 4);

d = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
    Oblig1.rotasjon(d, -6);

//但我得到java.lang.StackOverflowError这个数组

char[] x = new char[100_000];
    Oblig1.rotasjon(x, 99_999);

我知道数组很重要，但有可能解决这个问题，还是我必须回到传统的for循环？它必须在20毫秒内执行

Answer 1

我知道数组很重要，但有可能解决这个问题，还是我必须回到传统的for循环？

发生异常是因为递归太深;即它需要太多嵌套调用。

现在有多种语言，这无关紧要。例如，使用典型的函数语言，您可以根据需要进行深度递归。但有效的原因是函数式语言（以及许多其他语言）实现了一种称为尾部调用优化的东西，其中在方法调用结束时的递归调用被优化（由编译器）到跳转到开始的方法

参考：What Is Tail Call Optimization?

但Java不支持尾调用优化。（有一些合理但复杂的原因。）相反，每次调用都会在当前线程的堆栈上获得一个堆栈帧;即，N深递归需要N个堆栈帧。问题是Java线程具有固定数量的堆栈空间。（默认值通常为1M字节或更少。）创建后，无法扩展线程的堆栈。如果算法过于冗长，则线程会耗尽堆栈空间，并且JVM会引发异常...正如您所观察到的那样。

那么答案是什么？

一般来说，避免在Java中实现可能深度递归的算法：
- 如果算法是递归的，请尝试将其转换为迭代等价物;例如手动进行尾调优化。
- 如果算法是迭代的，请保持这样！
如果确实需要深度递归，可以将线程的maxiumum堆栈大小指定为构造函数参数。（我不确定是否存在架构限制，但您肯定会受限于可用的内存量......）

如果是这样，mabye你有一些建议吗？记住它必须在20毫秒内执行。

如果您的主要目标是有效地实现此目标，请不要使用递归而不是迭代。在Java中 - 它不会更快，并且总是存在堆栈溢出的潜在风险。
在这种情况下，请查看使用临时数组和System.arraycopy。（如果你旋转1，你不需要一个临时数组。你可以一步一步地按N旋转，但效率很低。）
在这种情况下，看看实现它，因为您只需要用两只手（临时变量）手动重新排列扑克牌。这样就可以在不使用N额外存储空间的情况下解决“O(N)”问题。

Answer 2

Paul Boddington建议使用System.arraycopy进行超快速旋转：

private static void rotate(char[] array, int distance) {
    if (array == null || array.length == 0)
        return; // nothing to rotate
    final int len = array.length;
    int d = distance % len; // eliminate distance overflow, e.g. for len=10, shift +28 is same as +8
    if (d == 0)
        return; // not rotating
    if (d < 0)
        d += len; // convert left shift to right shift, e.g. for len=10, -2 is same as +8
    if (d < len / 2) { // right shift less than half the array
        char[] temp = new char[d];
        System.arraycopy(array, len - d, temp, 0, d);  // save d values at end
        System.arraycopy(array, 0, array, d, len - d); // shift right by d
        System.arraycopy(temp, 0, array, 0, d);        // add saved value at start
    } else { // right shift more than half the array, so better to use left shift for smaller temp space
        d = len - d; // e.g. for len=10, right by 8 is left by 2
        char[] temp = new char[d];
        System.arraycopy(array, 0, temp, 0, d);        // save d values at start
        System.arraycopy(array, d, array, 0, len - d); // shift left by d
        System.arraycopy(temp, 0, array, len - d, d);  // add saved value at end
    }
}

测试

String s = "ABCDEFGHIJ";
for (int i = -11; i <= 11; i++) {
    char[] array = s.toCharArray();
    long start = System.nanoTime();
    rotate(array, i);
    long end = System.nanoTime();
    System.out.printf("%3d: %s   (%dns)%n", i, new String(array), end-start);
}

char[] x = new char[100_000];
for (int d : new int[] { 0, 1, 50_000, 99_999 }) {
    long start = System.nanoTime();
    rotate(x, d);
    long end = System.nanoTime();
    System.out.printf("%5d: %6dns = %fms%n", d, end-start, (end-start) / 1_000_000d);
}

输出

-11: BCDEFGHIJA   (7128ns)
-10: ABCDEFGHIJ   (285ns)
 -9: JABCDEFGHI   (856ns)
 -8: IJABCDEFGH   (855ns)
 -7: HIJABCDEFG   (855ns)
 -6: GHIJABCDEF   (855ns)
 -5: FGHIJABCDE   (855ns)
 -4: EFGHIJABCD   (855ns)
 -3: DEFGHIJABC   (856ns)
 -2: CDEFGHIJAB   (855ns)
 -1: BCDEFGHIJA   (855ns)
  0: ABCDEFGHIJ   (286ns)
  1: JABCDEFGHI   (855ns)
  2: IJABCDEFGH   (856ns)
  3: HIJABCDEFG   (1710ns)
  4: GHIJABCDEF   (856ns)
  5: FGHIJABCDE   (1141ns)
  6: EFGHIJABCD   (855ns)
  7: DEFGHIJABC   (856ns)
  8: CDEFGHIJAB   (855ns)
  9: BCDEFGHIJA   (571ns)
 10: ABCDEFGHIJ   (285ns)
 11: JABCDEFGHI   (855ns)

    0:    285ns = 0.000285ms
    1:  55885ns = 0.055885ms
50000:  43339ns = 0.043339ms
99999:  56169ns = 0.056169ms

Answer 3

Java不支持尾调用优化，因此您需要使用不同的算法或for循环。

Answer 4

您要做的是使用大小为100 000到1的输入数组调用该函数100 000次。您尝试装入内存的最大大小为（100 000 + 1）*（100 000/2）* 8（所有字符的大小）+ 100 000 * 8（数组引用的大小）+ 100 000 * 24（保持阵列结构所需的存储器）位。这是5 000 450 000字节或~5GB，因此是StackOverflowError。您仍然可以通过调整JVM来使其运行，但一般来说，对大型数据结构使用深度递归是一个非常糟糕的主意。

java堆栈溢出错误递归

4 个答案: