Java 在二进制搜索中，什么是'；返回'； 私有静态可比搜索（可比[]a，可比键，左整数， 整数（右）{ while（左0）{ 返回搜索（a，键，中间+1，右）； }否则{ 返回一个[mid]； } } 返回“未找到”； }

我对算法和递归有一个大致的了解，但在这一点上我感到困惑。如果第一个If语句运行4次，那么4次中的每一次都返回什么？实际价值是多少？所有堆栈的值是否都相同？这将是基本情况的[mid]

更新代码

编辑：

---

我的问题是，每次递归调用“return”时，在我到达基本情况并完成堆栈上的所有调用之后，它们的值是什么？如果第一个If语句运行两次，那么它在堆栈上有两个递归调用等待返回值。当递归完成时，返回值是什么

如果仍有值要检查（左索引小于或等于右索引），则

找到中点

如果关键点小于中点处的值，则调用搜索算法，但范围缩小（从左到中1）

如果关键点大于中点处的值，则调用搜索算法，但范围缩小（从中间到右侧+1）

如果键相等。。返回值

如果步骤1的测试失败，则钥匙不在范围内，因此返回not found

代码运行。。。你的问题是什么。这是一个完整的可执行程序，使用您的代码（完整）作为搜索方法。打印的行是

b

和

未找到

公共类BinSearch{

   private static Comparable search(Comparable[] a, Comparable key, int left,
            int right) {
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (key.compareTo(a[mid]) < 0) {                    
                return search(a, key, left, mid - 1);
            } else if (key.compareTo(a[mid]) > 0) {
                return search(a, key, mid + 1, right);
            } else {                        
                return a[mid];
            }
        }
        return "not found";

    }

public-BinSearch（）{
//TODO自动生成的构造函数存根
}
/**
*@param args
*/
公共静态void main（字符串[]args）{
字符串[]信息={“a”、“b”、“c”、“d”、“e”、“f”、“g”}；
字符串find=“b”；
字符串findToo=“x”；
System.out.println（搜索（info，find，0，info.length-1））；
System.out.println（搜索（info，findToo，0，info.length-1））；
//TODO自动生成的方法存根
}
专用静态可比搜索（可比[]a，可比键，左整数，
整数（右）{
while（左0）{
返回搜索（a，键，中间+1，右）；
}否则{
返回一个[mid]；
}
}
返回“未找到”；
}
}

下面是代码的作用：

如果仍有值要检查（左索引小于或等于右索引），则

找到中点

如果关键点小于中点处的值，则调用搜索算法，但范围缩小（从左到中1）

如果关键点大于中点处的值，则调用搜索算法，但范围缩小（从中间到右侧+1）

如果键相等。。返回值

如果步骤1的测试失败，则钥匙不在范围内，因此返回not found

代码运行。。。你的问题是什么。这是一个完整的可执行程序，使用您的代码（完整）作为搜索方法。打印的行是

b

和

未找到

公共类BinSearch{

   private static Comparable search(Comparable[] a, Comparable key, int left,
            int right) {
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (key.compareTo(a[mid]) < 0) {                    
                return search(a, key, left, mid - 1);
            } else if (key.compareTo(a[mid]) > 0) {
                return search(a, key, mid + 1, right);
            } else {                        
                return a[mid];
            }
        }
        return "not found";

    }

public-BinSearch（）{
//TODO自动生成的构造函数存根
}
/**
*@param args
*/
公共静态void main（字符串[]args）{
字符串[]信息={“a”、“b”、“c”、“d”、“e”、“f”、“g”}；
字符串find=“b”；
字符串findToo=“x”；
System.out.println（搜索（info，find，0，info.length-1））；
System.out.println（搜索（info，findToo，0，info.length-1））；
//TODO自动生成的方法存根
}
专用静态可比搜索（可比[]a，可比键，左整数，
整数（右）{
while（左0）{
返回搜索（a，键，中间+1，右）；
}否则{
返回一个[mid]；
}
}
返回“未找到”；
}
}

返回的是二进制搜索的原理，也就是说：如果键小于[mid]，则为外部边界（在该点上是正确的）变成值mid。基本上将项目数一分为二，并在每次测试键时对mid执行此操作，直到满足while条件。

返回的是二进制搜索的原理，即：如果键小于[mid]，则外部边界（在该点正确）变成值mid。基本上将项目数一分为二，每次测试键时都会这样做，直到满足while条件。

“我的问题是，每次递归调用“return”时，在到达基本情况和堆栈上的所有调用完成后，它们的值是多少？”

我添加了调试输出。在你的循环中仍然有一个bug，但是这应该是解决它的有用信息，它也应该回答你的问题

public BinSearch() {
    // TODO Auto-generated constructor stub
}

/**
 * @param args
 */
public static void main(String[] args) {
    String[] info = { "a", "b", "c", "d", "e", "f", "g" };
    String find = "b";
    String findToo = "x";

    System.out.println(search(info, find, 0, info.length - 1));
    System.out.println(search(info, findToo, 0, info.length - 1));
    // TODO Auto-generated method stub

}

private static Comparable search(Comparable[] a, Comparable key, int left,
        int right) {
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (key.compareTo(a[mid]) < 0) {
            return search(a, key, left, mid - 1);
        } else if (key.compareTo(a[mid]) > 0) {
            return search(a, key, mid + 1, right);
        } else {
            return a[mid];
        }
    }
    return "not found";

}

}

我的问题是，每次递归调用“return”时，在我到达基本情况并完成堆栈上的所有调用之后，它们的值是多少

我添加了调试输出。在你的循环中仍然有一个bug，但是这应该是解决它的有用信息，它也应该回答你的问题

public BinSearch() {
    // TODO Auto-generated constructor stub
}

/**
 * @param args
 */
public static void main(String[] args) {
    String[] info = { "a", "b", "c", "d", "e", "f", "g" };
    String find = "b";
    String findToo = "x";

    System.out.println(search(info, find, 0, info.length - 1));
    System.out.println(search(info, findToo, 0, info.length - 1));
    // TODO Auto-generated method stub

}

private static Comparable search(Comparable[] a, Comparable key, int left,
        int right) {
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (key.compareTo(a[mid]) < 0) {
            return search(a, key, left, mid - 1);
        } else if (key.compareTo(a[mid]) > 0) {
            return search(a, key, mid + 1, right);
        } else {
            return a[mid];
        }
    }
    return "not found";

}

}

---

没有东西能跑四次。“while”只执行一次。如果主体被执行，它将返回一些内容。“while”应该是“if”。

没有任何东西会运行四次。“while”只执行一次。如果主体被执行，它将返回一些内容。“while”应该是一个“if”。

是的，它在所有父调用中都是相同的值。 这样想，如果一个子调用找到了对象，那么它将返回该对象，父调用将返回子调用返回的内容，接下来父调用将成为另一个父调用的子调用，同样的情况也会发生。 很难用语言来解释它，但它只是逻辑和递归的魔力，而我们的大脑却不是

inputList = [1, 2, 3, 4, 5, 6, 7]

 return binary_search_on(inputList)
 ------------------------
 binary_search_on: [1,2,3,4,5,6,7]
      var middle = 4
      4 == 6? nope. 
         so, is 4 < 6? nope, crap. 
            bah! 4 > 6 ? yes.  return binary_search_on([5, 6, 7])
 ------------------------
 binary_search_on: [5,6,7]
      var middle = 6
      6 == 6? cool. return 6

 return binary_search_on(inputList)
 ------------------------
 binary_search_on: [1,2,3,4,5,6,7]
      var middle = 4
      4 == 6? nope. 
         so, is 4 < 6? nope, crap. 
            bah! 4 > 6 ? yes.  return 6

 return 6