Java if，else if，else语句中的Return语句不起作用

我在代码中偶然发现了一些问题，假设返回将停止我的方法，但在我的情况下不是。我试图创建一个名为“binarySearch”的方法，该方法可以完成它的任务

public int binarySearch(int lowIndex, int highIndex, int[] arr, int val) {
    int middleIndex = (lowIndex + highIndex ) / 2;
    if(arr[middleIndex] < val) {
        lowIndex = middleIndex;
    } else if (arr[middleIndex] > val) {
        highIndex = middleIndex;
    } else {
        return middleIndex;
    }
    binarySearch(lowIndex, highIndex, arr, val);
    return 0;
}

public int-binarySearch（int-lowIndex，int-highIndex，int[]arr，int-val）{
中间指数=（低指数+高指数）/2；
if（arr[middleIndex]val）{
高指数=中指数；
}否则{
回归指数；
}
二进制搜索（低索引、高索引、arr、val）；
返回0；
}

---

问题是如果我已经找到了搜索值所在的索引，else语句将返回它并停止。但是，我总是得到“0”，这是我为默认返回设置的值

return0

。为了澄清一下，我在else语句中添加了一些文本，以确保它执行并返回

middleIndex

，然后文本显示出来，基本上我的循环进入else语句并希望返回

middleIndex

，但它不是。也许递归与此有关，但我不知道你们是否可以帮助我。

你们必须返回递归的结果。您可以参考下面显示的代码来了解您做错了什么

  // Returns index of x if it is present in arr[l..
    // r], else return -1
    int binarySearch(int arr[], int l, int r, int x)
    {
        if (r>=l)
        {
            int mid = l + (r - l)/2;

            // If the element is present at the 
            // middle itself
            if (arr[mid] == x)
               return mid;

            // If element is smaller than mid, then 
            // it can only be present in left subarray
            if (arr[mid] > x)
               return binarySearch(arr, l, mid-1, x);

            // Else the element can only be present
            // in right subarray
            return binarySearch(arr, mid+1, r, x);
        }

        // We reach here when element is not present
        //  in array
        return -1;
    }

---

有关BinarySearch及其实现的更多信息，您可以遵循链接，因为您的方法的签名是

public int BinarySearch

，这意味着您应该从

BinarySearch

方法的递归调用返回int。在这个方法的正确实现中，您不应该返回0。

这里是用于二进制搜索的迭代java代码，您的代码有点缺陷

int binarySearch(int arr[], int x) {
    int l = 0, r = arr.length - 1;

    while (l <= r) {

        int m = l + (r-l)/2;

        if (arr[m] == x)
            return m;

        if (arr[m] < x)
            l = m + 1;

        else
            r = m - 1;
    }

    return -1;
}

int二进制搜索（int-arr[]，int-x）{
int l=0，r=arr.length-1；
而（l
publicstaticvoidbinarysearch（int-arr[]，int-first，int-last，int-key）{
int mid=（第一个+最后一个）/2；
而（前最后）{
System.out.println（“未找到元素！”）；
}  

您也可以通过递归来实现。
代码中有一些小错误

在递归中，当函数递归地调用自身时，函数调用应该放在return语句中。这可以确保递归函数调用的结果返回给调用函数

这是修改后的代码-

class BinarySearch
{
    // Returns index of x if it is present in arr[l..
    // r], else return 0

    public int binarySearch(int lowIndex, int highIndex, int[] arr, int val) 
    {
        if(highIndex>=lowIndex)  //this line should be added for safety
        {
            int middleIndex = (lowIndex + highIndex ) / 2;
            if(arr[middleIndex] < val) 
            {
                lowIndex = middleIndex;
            } 
            else if (arr[middleIndex] > val) 
            {
                highIndex = middleIndex;
            } 
            else 
            {
                return middleIndex;
            }
            return binarySearch(lowIndex, highIndex, arr, val);  //this should be the return statement
        }
        return 0;
    }

    // Driver method to test above
    public static void main(String args[])
    {
        BinarySearch ob = new BinarySearch();
        int arr[] = {1,2,3,4,5,6,7,8};
        int n = arr.length;
        int x = 7;
        int result = ob.binarySearch(0,n-1,arr,x);
        if (result == 0)
            System.out.println("Element not present");
        else
            System.out.println("Element found at index " + result);
    }
}

类二进制搜索
{
//如果在arr[l]中存在，则返回x的索引。。
//r]，否则返回0
公共整数二进制搜索（整数低索引、整数高索引、整数[]arr、整数val）
{
if（highIndex>=lowIndex）//为安全起见，应添加此行
{
中间指数=（低指数+高指数）/2；
if（arr[middleIndex]val）
{
高指数=中指数；
} 
其他的
{
回归指数；
}
return binarySearch（lowIndex，highIndex，arr，val）；//这应该是return语句
}
返回0；
}
//以上测试的驱动程序方法
公共静态void main（字符串参数[]）
{
BinarySearch ob=新的BinarySearch（）；
int arr[]={1,2,3,4,5,6,7,8}；
int n=阵列长度；
int x=7；
int result=ob.binarySearch（0，n-1，arr，x）；
如果（结果==0）
System.out.println（“元素不存在”）；
其他的
System.out.println（“在索引中找到的元素”+结果）；
}
}

这段代码运行良好

上述代码的递归堆栈解释-

二进制搜索（0,7，arr，val）

=返回（二进制搜索（3,7，arr，val））

=返回（返回（二进制搜索（5,7，arr，val）））

=return（return（return 6））//这里6是在else块中返回的中间值

=返回（返回6）

=返回6

因为您没有在代码中添加return语句，所以递归堆栈中最顶层的函数调用返回0。
您没有返回递归的结果。我不熟悉递归。您可以修改代码使其工作吗？因为我知道我是通过else语句返回的，据我所知，递归在那里停止hehe THX您从else返回它，但在这一行忽略它：
binarySearch（低索引、高索引、arr、val）；
binarySearch
正在使用传递给它的相同参数调用自己。除了无限循环和最终的堆栈溢出异常之外，这怎么会产生任何其他结果？@KevinAnderson不，它没有使用相同的参数调用自己。它要么返回找到的索引（否则）或修改
低索引
（如果是大小写）或
高索引
（如果是大小写）在调用它自己的Thank mate之前，您向我的代码解释了什么地方出了问题，并给出了如何操作的提示。对此，我投赞成票。@YihangWang在Java中编写几乎所有递归函数时所冒的风险，对于op来说，这实际上不太可能是一个问题。谢谢您的帮助mate，但我只能选择一个答案，顺便说一句，谢谢：）当然你可以选择最好的答案。向上投票，如果它有助于Hanks mate，但是swapnil解释了我的代码有什么问题，为什么我选择他的答案，顺便说一句，谢谢：）
class BinarySearch
{
    // Returns index of x if it is present in arr[l..
    // r], else return 0

    public int binarySearch(int lowIndex, int highIndex, int[] arr, int val) 
    {
        if(highIndex>=lowIndex)  //this line should be added for safety
        {
            int middleIndex = (lowIndex + highIndex ) / 2;
            if(arr[middleIndex] < val) 
            {
                lowIndex = middleIndex;
            } 
            else if (arr[middleIndex] > val) 
            {
                highIndex = middleIndex;
            } 
            else 
            {
                return middleIndex;
            }
            return binarySearch(lowIndex, highIndex, arr, val);  //this should be the return statement
        }
        return 0;
    }

    // Driver method to test above
    public static void main(String args[])
    {
        BinarySearch ob = new BinarySearch();
        int arr[] = {1,2,3,4,5,6,7,8};
        int n = arr.length;
        int x = 7;
        int result = ob.binarySearch(0,n-1,arr,x);
        if (result == 0)
            System.out.println("Element not present");
        else
            System.out.println("Element found at index " + result);
    }
}