这个代码有错误，没找到，可以帮我找一下嘛


System.out.print("请输入要查找的数：");
        Scanner scan=new Scanner(System.in);
        int num=scan.nextInt();
        scan.close();
        int left=0,right=arr.length-1; //左边界为0，有边界为最大索引值
        int m=-1;
        while(left<=right) {
            int mid=(right+left)/2;
            if(arr[mid]<num)
                right=mid-1;//若中间值比查找值小，就把右边界换为中间值
            else if(arr[mid]>num)
                left=mid+1;//若中间值比查找值大，就把左边界换为中间值
            else {
                m=mid;//若相等，找到元素的索引值，退出循环
                break;
            }    
        }
        System.out.print("所查找的数的索引值为："+m);
    }
}

如果查找的数不在数组中，最终输出的索引值为 -1，而不是一个明确的提示。可以在输出时增加一些判断，如果 m 的值为 -1，则输出“未找到该元素”的提示。

这个代码是一个二分查找的实现，但是有一个错误：如果要查找的数不在数组中，程序会输出一个错误的结果。

具体来说，当left>right时，说明要查找的数不在数组中，但此时程序仍然会输出一个m的值，这个值可能是上一次循环的mid值，而不是-1，即数组中不存在要查找的数。

为了解决这个问题，可以将m的初始化改为-1，表示要查找的数不存在于数组中，同时在while循环中加入一个判断，如果left>right，则跳出循环，不再继续查找。最后再输出m的值即可。

以下是修改后的代码：

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        System.out.print("请输入要查找的数：");
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        scan.close();
        int left = 0, right = arr.length - 1; //左边界为0，有边界为最大索引值
        int m = -1;
        while (left <= right) {
            int mid = (right + left) / 2;
            if (arr[mid] < num)
                right = mid - 1;//若中间值比查找值小，就把右边界换为中间值
            else if (arr[mid] > num)
                left = mid + 1;//若中间值比查找值大，就把左边界换为中间值
            else {
                m = mid;//若相等，找到元素的索引值，退出循环
                break;
            }
            if (left > right) { // 如果left>right，说明要查找的数不在数组中，跳出循环
                break;
            }
        }
        System.out.print("所查找的数的索引值为：" + m);
    }
}

不知道你这个问题是否已经解决, 如果还没有解决的话:

帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7534958
我还给你找了一篇非常好的博客，你可以看看是否有帮助，链接：凯撒密码的加密，破解，以及暴力破解法

除此之外, 这篇博客: 双轴快排算法，听说过没？中的 一、单轴快排 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:

示例：单轴快排也就是我们常说的普通快速排序，对于快速排序我想大家应该都很熟悉：基于递归和分治的，时间复杂度最坏而O(n2),最好和平均情况为O(nlogn).

而快排的具体思路也很简单，每次在待排序序列中找一个数(通常最左侧多一点)，然后在这个序列中将比他小的放它左侧，比它大的放它右侧。在这里插入图片描述
如果运气肯不好遇到O(n)平方的，那确实就很背啦：

实现起来也很容易，这里直接贴代码啦：

 private static void quicksort(int[] a, int left, int right) {
        int low = left;
        int high = right;
        //下面两句的顺序一定不能混，否则会产生数组越界！！！very important！！！
        if (low > high)//作为判断是否截止条件
            return;
        int k = a[low];//额外空间k，取最左侧的一个作为衡量，最后要求左侧都比它小，右侧都比它大。
        while (low < high)//这一轮要求把左侧小于a[low],右侧大于a[low]。
        {
            while (low < high && a[high] >= k)//右侧找到第一个小于k的停止
            {
                high--;
            }
            //这样就找到第一个比它小的了
            a[low] = a[high];//放到low位置
            //在low往右找到第一个大于k的，放到右侧a[high]位置
            while (low < high && a[low] <= k) {
                low++;
            }
            a[high] = a[low];
        }
        //赋值然后左右递归分治求之
        a[low] = k;
        quicksort(a, left, low - 1);
        quicksort(a, low + 1, right);
    }
     public static void main(String[] args) {
        int a[] = {7, 3, 5, 4, 8, 5, 6, 55, 4, 333, 44, 7, 885, 23, 6, 44};
        quicksort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));
    }

您还可以看一下任大勇老师的人工智能算法竞赛实战课程中的特征工程—特征强化小节, 巩固相关知识点

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^