Question

我正在尝试将这种递归方法转换为迭代方法而且我有点卡住，因为我的书不能解释它。此方法在两个值之间搜索特定值的数组并返回索引。任何帮助或正确方向的观点都将受到赞赏。

public static int binarySearch(int anArray[], int first, int last, int value) {
    int index;

    if (first > last) {
        index = -1;
    } else {
        int mid = (first + last) / 2;

        if(value == anArray[mid]) {
            index = mid;
        } else if(value < anArray[mid]) { //Point x
            index = binarySearch(anArray, first, mid - 1, value);
        } else { //Point Y
            index = binarySearch(anArray, mid + 1, last, value);
        }
    }

    return index;
}

Answer 1

在这个实例中，它实际上是一个非常简单的转换。基本上，您只需将整个事物包装在循环中，然后修改参数而不是进行递归调用。

在函数中有多个递归调用的情况下（例如遍历树），它会变得复杂得多;但是，在这种情况下，迭代版本和递归版本几乎完全相同。

public static int binarySearch(int anArray[], int first, int last, int value) {

    do {
        if (first > last) {
            return -1;
        } else {
            int mid = (first + last) / 2;

            if(value == anArray[mid]) {
                return mid;
            } else if(value < anArray[mid]) { //Point x
                last = mid - 1;
                //index = binarySearch(anArray, first, mid - 1, value);
            } else { //Point Y
                first = mid + 1;
                //index = binarySearch(anArray, mid + 1, last, value);
            }
        }
    }
    while(true);
}

Answer 2

这可以在你有尾调用时完成。考虑一下

int f(int x, int y) {
  if (x == 0) { return y; }
  return f(y - 1, x);
}

相当于

int f(int x, int y) {
  while (true) {
    // The body of your method goes here as normal.
    if (x == 0) { return y; }
    // Instead of returning the result of a recursive call though,
    // compute the parameters to tail call
    int newX = y - 1;
    int newY = x;
    // overwrite parameters with values to tail call
    x = newX;
    y = newY;
    // let the loop jump us back to the top of the method.
    continue;  // You can put continue in place of return
  }
}

当你的方法调用其他方法时，这些在语义上并不相同，因为Java允许Call stack introspection但是由于调用堆栈与被调用者不同而你不太可能遇到问题 - 最有可能你遇到的问题是你会得到一个无限循环而不是StackOverflowError。

Answer 3

你这样做。识别参数并将它们转换为循环变量。而不是调用函数，更新变量。而不是从函数返回 - 退出循环：

public static int binarySearch(int anArray[], int first, int last, int value) {
  int index;
  int done = 0;              // LOOP CONTROL

  while (done == 0) {        // A LOOP:

    if (first > last) {
        index = -1;          // RETURN ---> EXIT FROM LOOP
        done = 1;
    } else {
        int mid = (first + last) / 2;

        if(value == anArray[mid]) {
            index = mid;     // RETURN ---> EXIT FROM LOOP
            done = 1;
        } else if(value < anArray[mid]) { //Point x
            // index = binarySearch(anArray, first, mid - 1, value);
            // CALL ---> UPDATE THE VARIABLES
            last = mid-1;
        } else { //Point Y
            // index = binarySearch(anArray, mid + 1, last, value);
            // CALL ---> UPDATE THE VARIABLES
            first = mid+1;
        }
    }
  } // END LOOP

  return index;
}

Answer 4

我可以假设，在第一次调用此方法时，first=0和last=anArray.length。

从那里开始，我会建议以下

public static int binarySearch_iterative(int[] anArray, int value) {
    int first, last, mid, index;
    first = 0;
    last = anArray.length - 1; // The last cell of the array

    while(first <= last) {
        mid = (first + last) / 2;
        if(anArray[mid] == value) {
            index = mid;
            break;
        } else {
            if(value < anArray[mid]) {
                last = mid;
            } else {
                first = mid;
            }
        }
        if(first > last) {
            index = -1;
            break;
        }
    }
    return index;
}

我希望这会对你有所帮助。

将递归转换为迭代

4 个答案: