primary 03-01: 二分法及进阶问题

最新推荐文章于 2024-06-27 18:41:33 发布
最新推荐文章于 2024-06-27 18:41:33 发布
阅读量474 收藏 1
点赞数
分类专栏： 算法 文章标签： 排序算法 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_40865448/article/details/121277756
版权
本文介绍了如何运用二分法在不同场景下解决查找问题，包括在有序数组中找到大于等于目标值的最左位置和小于等于目标值的最右位置。同时，详细探讨了在无序数组中寻找局部最小值的问题，通过二分法实现高效解决方案，并提供了代码实现和测试案例。二分法不仅限于有序数组，只要有合适的判断标准，就能在满足条件的数组中有效搜索目标值。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

二分法

先说一个东西，确定左右边界的时候，有个技巧目前一直遵守：
就是

if () {
	L = mid + 1;
}else(){
	R = mid - 1;
}

大概意思就是，L与R，一个是 (mid + 1) 时，如果else/else if/if条件中是确定另一个边界，则另一边界值为 （mid - 1）–> 可直接写。

  1. 基本二分法 （加入对数器验证）
import java.util.Arrays;

public class BinarySearch {
    public static boolean binarySearch(int[] arr, int target) {
        if (arr == null || arr.length == 0) {
            return false;
        }
        int L = 0;
        int R = arr.length - 1;
        while (L <= R) {
            int mid = (L + R) / 2;
            if (arr[mid] == target) {
                return true;
            } else if (arr[mid] < target) {
                L = mid + 1;
            } else {
                R = mid - 1;
            }
        }
        return false;
    }

    // 对数器
    public static boolean test(int[] arr, int target) {
        for (int num : arr) {
            if (num == target) {
                return true;
            }
        }
        return false;
    }

    // 随机数组生成器
    public static int[] lenRandomValueRandom(int maxLen, int maxValue) {
        int len = (int) (Math.random() * maxLen); // int [0, maxLen - 1]
        int[] arr = new int[len];
        for (int i = 0; i < len; i++) {
            arr[i] = (int) (Math.random() * maxValue); // int [0, maxValue - 1]
        }
        return arr;
    }

    public static int[] copyArray(int[] oldArr) {
        int[] newArr = new int[oldArr.length];
        for (int i = 0; i < oldArr.length; i++) {
            newArr[i] = oldArr[i];
        }
        return newArr;
    }

    public static void main(String[] args) {
        int maxLen = 50;
        int maxValue = 1000;
        int testTimes = 10000;
        // 开始实测
        for (int i = 0; i < testTimes; i++) {
            int[] arr = lenRandomValueRandom(maxLen, maxValue);
            // 二分法检测 一定要保证 ！！！数组已经排序！！！
            Arrays.sort(arr);
            int[] tmp = copyArray(arr);
            int target = (int) (Math.random() * (maxValue + 1)) - (int) (Math.random() * maxValue);
            if (binarySearch(arr, target) != test(arr, target)) {
                System.out.println("结果有误");
                for (int j = 0; j < tmp.length; j++) {
                    System.out.print(tmp[j] + " ");
                }
                System.out.println();
                System.out.println("搜索数字为" + target);
                break;
            };

        }
    }
}

二分进阶

  1. 在有序数组中找到 >= num 最左的位置
  2. 在有序数组中找到 <= num 最右的位置
package class03;

import java.util.Arrays;

public class BSNearLeft {
    // arr是有序的， 寻找 >= num 的最左位置
    public static int bsNearLeft(int[] arr, int num) {
        if (arr == null || arr.length == 0) {
            // -1表示该数组无法返回所求条件 --> -1代表特殊情况
            return -1;
        }
        int L = 0;
        int R = arr.length - 1;
        // Step 1: 初始化 存储的目标值 ans --> -1 表示不存在
        int ans = -1;
        while (L <= R) {
            // Step 2: 更新 ans
            int mid = (L + R) / 2;
            if (arr[mid] >= num) {
                ans = mid;
                R = mid - 1;
            } else { // arr[mid] < num
                L = mid + 1;
            }
        }
        // Step 3: 返回 ans
        return ans;
    }

    // 返回 <= num 的最右, 前提：数组有序
    public static int bsNearRight(int[] arr, int num) {
        if (arr == null || arr.length == 0) {
            return -1;
        }
        int L = 0;
        int R = arr.length - 1;
        int ans = -1;
        while (L <= R) {
            int mid = (L + R) / 2;
            if (arr[mid] <= num) {
                ans = mid;
                L = mid + 1;
            } else {
                R = mid - 1;
            }
        }
        return ans;
    }

    // 对数器 --> 确认结果的检查器  功能：检查 >= num 的最左
    // 前提： arr是有序的
    public static int checkNearLeft(int[] arr, int num) {
        if (arr.length == 0) {
            return -1;
        }
        int ans = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= num) {
                ans = i;
                break;
            }
        }
        return ans;
    }

    // 检查 <= num 的最右
    public static int checkNearRight(int[] arr, int num) {
        if (arr.length == 0) {
            return -1;
        }
        int ans = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] <= num) {
                ans = i;
            } else {
                break;
            }
        }
        return ans;
    }

    public static int[] randomArray(int maxLen, int maxValue) {
        int len = (int) (Math.random() * maxLen);
        int[] arr = new int[len];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * maxValue);
        }
        return arr;
    }

    public static void main(String[] args) {
        int maxLen = 20;
        int maxValue = 10000;
        int testTimes = 10000;
        for (int i = 0; i < testTimes; i++) {
            int[] arr = randomArray(maxLen, maxValue);
            int num = (int) (Math.random() * (maxValue + 1)) - (int) (Math.random() * maxValue);
            Arrays.sort(arr);
            if (checkNearLeft(arr, num) != bsNearLeft(arr, num)) {
                System.out.println(">=num最左 的 结果出错");
                System.out.println(Arrays.toString(arr));
                System.out.println(num);
                System.out.println(checkNearLeft(arr, num));
                System.out.println(bsNearLeft(arr, num));
                break;
            }
            if (checkNearRight(arr, num) != bsNearRight(arr, num)) {
                System.out.println("<=num最右 结果出错");
            }
        }
    }
}
  1. 局部最小值问题 ----》 无序 ，相邻不等
    前提： 数组无序，且任意两个相邻的位置 数值不相等（arr[i] != arr[i + 1], i [0, arr.length - 2]）

局部最小的定义：
（1）左边界局部最小：arr[0] < arr[1];
（2）右边界局部最小：arr[N - 1] < arr[N -2];
（3）普遍(中间)：arr[i - 1] > arr[i] < arr[i + 1];
(4) （可以理解为左边界左边或右边界右边 大小为无限大）此条可忽略，coding时 可利用这种思路

问题： 找到第一个局部最小值？

解决方法： 二分法
个人代码：

package class03;

import java.util.Arrays;

public class BSAwesome {
    // arr 无序
    // arr 相邻元素 不相等
    // 功能： 找出arr中 任意局部最小的index索引
    // 输入： 数组  ---> int[] arr
    // 输出： 局部最小的元素的索引下标 ---> int类型
    public static int oneMinIndex(int[] arr) {
        // 特殊情况 ---> summary: 一般对 arr == null, length == 0, length == 1,进行特殊处理
        if (arr == null || arr.length == 0) {
            // 返回 -1 表示无目标元素
            return -1;
        }
        int N = arr.length;
        // 长度为 1 ---> 直接返回唯一元素下标 0
        if (N == 1) {
            return 0;
        }
        // 考虑 length == 2 的情况 ---> length >= 2时， 统一处理
        //首先确定左右边界，是否为局部最小
        if (arr[0] < arr[1]) {
            return 0;
        }
        if (arr[N - 1] < arr[N - 2]) {
            return N - 1;
        }
        // 如果边界都不为局部最小，则 [L, R]中，必有局部最小，因为（1）相邻元素不相等，必有一大一小
        // （2） 画一下图就可知道，必有 先向下，再向上 的拐点
        int L = 0;
        int R = arr.length - 1;
        int ans = -1;
        // 开始二分法  ---> 为什么也可以考虑到二分，因为它也是在找数字，具体看solution
        // 这里，我们要对 arr进行二分，对每个arr[mid] 进行局部最小的比较,注意 考虑边界导致的特殊情况
        // 特殊处理理解： 数组中的任何一个元素，都有可能二分到，所以要考虑任何一个元素 是否出现越界的情况
        while (L <= R) {
            int mid = (L + R) / 2;
            // 特殊情况要先处理
            // 左边界
            if (mid == 0) {
                L = mid + 1;
                // 一定要注意， 执行完之后，不添加continue 还会继续往后做，出现越界
                continue;
            }
            if (mid == N - 1) {
                R = mid - 1;
                continue;
            }
            // 现在 出现的所有元素 都是有左右元素
            if (arr[mid] < arr[mid + 1] && arr[mid] < arr[mid - 1]) {
                ans = mid;
                break;
            } else if (arr[mid] > arr[mid - 1]) {
                // 只要arr[mid] > arr[mid - 1]， 那么[L, mid - 1]一定存在局部最小
                R = mid - 1;
            } else { // arr[mid] > arr[mid + 1]
                L = mid + 1;
            }
        }
        return ans;
    }

    // Start 对数器 ---> 自动生成随机数样本进行比对的机器
    // 随机数组生成器 ---> 但是这次有要求， 无序->OK, 相邻不重复->(improve)修改下代码
    public static int[] randomArray(int maxLen, int maxValue) {
        // 生成数组
        int len = (int) (Math.random() * maxLen);
        int[] arr = new int[len];
        // 开始赋值 ， 首先遍历数组 然后赋值
        // 首先特殊情况
        if (len == 0) {
            return arr;
        }
        // 开始正常情况, 首先赋值arr[0]
        arr[0] = (int) (Math.random() * maxValue);
        // 注意i 从 1 开始   ----> 然后赋值 arr[1] -> arr[N - 1]
        for (int i = 1; i < arr.length; i++) {
            do {
                arr[i] = (int) (Math.random() * maxValue);
            } while (arr[i] == arr[i - 1]);
        }
        return arr;
    }

    // 比对器 (两个方向 ： 一个是生成正确结果，然后与测试函数进行比较； 另一个是将测试函数的结果作为参数，进行正误校验) ---->
    public static boolean check(int[] arr, int minIndex) {
        // 特殊情况处理
        if (arr.length == 0) {
            return minIndex == -1;
        }
        int left = minIndex - 1;
        int right = minIndex + 1;
        // 简化代码 --> boolean ---> （左边界结果 & 右边界结果） ---> 从而可以分开处理
        boolean leftResult = left >= 0 ? arr[minIndex] < arr[left] : true;
        // minIndex < arr.length - 1
        boolean rightResult = right < arr.length ? arr[minIndex] < arr[right] : true;
        return leftResult & rightResult;
    }

    public static void main(String[] args) {
        int maxLen = 100;
        int maxValue = 200;
        int testTime = 10000;
        System.out.println("测试开始");
        for (int i = 0; i < testTime; i++) {
            int[] arr = randomArray(maxLen, maxValue);
            int ans = oneMinIndex(arr);
            boolean succeed = check(arr, ans);
            if (!succeed) {
                Arrays.toString(arr);
                System.out.println("测试失败");
                return;
            }
        }
        System.out.println("测试成功");
    }
}

第二版本： 左神代码

package class03;

public class Code04_BSAwesome {

    // arr 整体无序
    // arr 相邻的数不相等！
    public static int oneMinIndex(int[] arr) {
        if (arr == null || arr.length == 0) {
            return -1;
        }
        int N = arr.length;
        if (N == 1) {
            return 0;
        }
        if (arr[0] < arr[1]) {
            return 0;
        }
        if (arr[N - 1] < arr[N - 2]) {
            return N - 1;
        }
        int L = 0;
        int R = N - 1;
        // L...R 肯定有局部最小
        while (L < R - 1) { // 确保有三个元素
            int mid = (L + R) / 2;
            if (arr[mid] < arr[mid - 1] && arr[mid] < arr[mid + 1]) {
                return mid;
            } else {
                if (arr[mid] > arr[mid - 1]) {
                    R = mid - 1;
                } else {
                    L = mid + 1;
                }
            }
        }
        return arr[L] < arr[R] ? L : R;
    }

    // 生成随机数组，且相邻数不相等
    public static int[] randomArray(int maxLen, int maxValue) {
        int len = (int) (Math.random() * maxLen);
        int[] arr = new int[len];
        if (len > 0) {
            arr[0] = (int) (Math.random() * maxValue);
            for (int i = 1; i < len; i++) {
                do {
                    arr[i] = (int) (Math.random() * maxValue);
                } while (arr[i] == arr[i - 1]);
            }
        }
        return arr;
    }

    // 也用于测试
    public static boolean check(int[] arr, int minIndex) {
        if (arr.length == 0) {
            return minIndex == -1;
        }
        int left = minIndex - 1;
        int right = minIndex + 1;
        boolean leftBigger = left >= 0 ? arr[left] > arr[minIndex] : true;
        boolean rightBigger = right < arr.length ? arr[right] > arr[minIndex] : true;
        return leftBigger && rightBigger;
    }

    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int maxLen = 100;
        int maxValue = 200;
        int testTime = 1000000;
        System.out.println("测试开始");
        for (int i = 0; i < testTime; i++) {
            int[] arr = randomArray(maxLen, maxValue);
            int ans = oneMinIndex(arr);
            if (!check(arr, ans)) {
                printArray(arr);
                System.out.println(ans);
                break;
            }
        }
        System.out.println("测试结束");
        
    }
}

总结：
二分是不是一定要有序？ 不是
在某一种标准下，比如局部最小问题， 只要你能保证有一侧肯定有，你就可以使用二分法。

MySQL 03、深入浅出索引
sowhat
08-31 739
引言 提到数据库索引，我想你并不陌生，在日常工作中会经常接触到。比如某一个SQL查询比较慢，分析完原因之后，你可能就会说 给某个字段加个索引吧 之类的解决方案。但到底什么是索引，索引又是如何工作的呢？今天就让我们一起来聊聊这个话题吧。 索引是数据库系统里面最重要的概念之一，一句话简单来说，索引的出现其实就是为了提高数据查询的效率，就像书的目录一样。一本500页的书，如果你想快速找到其中的某一个知识点，在不借助目录的情况下，那我估计你可得找一会儿。同样，对于数据库的表而言，索引其实就是它的目录。 索引的常见模
【Mysql进阶】5步轻松掌握MySQL索引匹配顺序，你还在盲目查询吗？
最新发布
java专栏
11-08 980
假设我们在创建users表时，直接在username和email列上定义复合索引。-- 创建表并定义复合索引通过以上五个步骤，相信你已经掌握了MySQL索引匹配顺序的使用技巧。合理地创建和管理索引是数据库优化的重要一环，可以显著提高查询性能，确保数据的快速检索。下次遇到数据库查询性能问题时，不妨从本文的步骤入手，或许你会有意想不到的收获哦！
二分法的改进方法（C++）（Fibonacci Search）
in_the_end__的博客
10-10 1529
二分法的改进方法（C++）（Fibonacci Search）
优化——使用“二分法”快速建立数据树
JRQ 的博客
02-20 1723
标题：优化——使用“二分法”快速建立数据树内容：父子节点的数据量上万，花了一个晚上的时间对建树的算法做了优化。比用循环查找父节点来建树的速度快多了。 ^_^谨记之。备注：对数据表中父子节点的数据如下形式的可以使用本算法。  DID     PID       FLMC   1        0        A   2        0        B   3      
二分法优化
weixin_33717298的博客
07-17 994
1,基本的二分思想： int BinarySearch(int a[],int size,int key) { int L = 0; //查找区间的左端点 int R = size - 1; //查找区间的右端点 while( L <= R) { //如果查找区间不为空就继续查找 int mid = L+(R-L)/2; ...
二分法及其优化
lxs2016的博客
07-14 7576
二分查找 ，将所给关键词和指定有序集合中间数进行比较，如果比较相等则返回结果，如果不相等，则按照所给出的结果，将集合减半后继续查找 //二分查找（折半查找） int BinarySearch1(int a[], int value, int n) {     int low, high, mid;     low = 0;     high = n-1;       while(low     {
最优化学习笔记（二）——二分法
chunyun0716的专栏
05-14 7015
二分法是一种一维搜索方法。它讨论的是求解一元单值函数f:R→R在区间[a0,b0]f: \mathbb{R} \to \mathbb{R} 在区间[a_0, b_0]的极小点问题。同时要求函数ff在区间[a0,b0][a_0, b_0]上为单调函数，并且是连续可微的，这里将使用ff的一阶导数f′f'。       二分法的计算过程比较简单，它主要是利用一阶导数来连续压缩区间的方法。 1.确定初
MYSQL 四、mysql进阶 5（InnoDB数据存储结构）
kkkkatoq的博客
06-27 933
页a、页b、页c...页n这些可以不在物理结构上相连，只要通过双向链表相关联即可，每个数据页中的记录会按照主键值从小到大的顺序组成一个单向链表，每个数据页都会为存储在它里面的记录生成一个页目录，在通过主键查找某条记录的时候可以在页目录中使用二分法快速定位到对应的槽，然后再遍历该槽对应分组中的记录即可，快速找到指定的记录。
MYSQL 四、mysql进阶 4（索引的数据结构）
kkkkatoq的博客
06-19 1085
1.为什么使用索引 索引是存储引擎用于快速找到数据记录的一种数据结构，就好比一本教科书的目录部分，通过目录中找到对应文章的页码，便可快速定位到需要的文章。Mysql中也是一样的道理，进行数据查找时，首先查看查询条件是否命中某条索引，符合则通过索引查找相关数据，如果不符合则需要全表扫描，即需要一条一条的查找记录，直到找到与条件符合的记录。 ​​​​ 如上图所示，数据库没有索引的情况下，数据 分布在硬盘的不同位置上面，读取数据时，摆臂需要前后摆动查找数据，这样操作非
【快速定位故障并恢复正常服务】：故障诊断与恢复的高效方法
!... # 摘要 本文系统地探讨了故障诊断与恢复的理论基础和实践技巧，分析了故障的定义、分类及其诊断工具和技术。...进阶方法部分涵盖了自动化诊断工具、处理复杂故障场景的策略以及长期故障预防和系统
无约束优化方法，二分法，黄金分割法等
12-11
VC实现的，一维搜索，黄金分割法，二分法，三点法，牛顿法
用二分法优化动态规划——实现快速决策
TechFlow的博客
04-23 540
本文始发于个人公众号：TechFlow，原创不易，求个关注 今天是算法与数据结构专题的17篇文章，也是动态规划专题的第6篇。 今天我们一起来看一道非常经典的动态规划的问题，有多经典呢？我想了一下，大概是我这辈子做的最早的一道动态规划问题，以至于我现在都记得它的题面。 题面 这道题就是导弹拦截系统，说是某一个国家开发了一套导弹拦截系统，这个拦截系统可以拦截敌国打来的导弹。不同射程的导弹在弹射出去的...
组合最优化——二分法
君陌的博客
11-05 1386
若f(x)的导数存在且容易计算，则线性搜索的速度可以得到提高,下面的二分法每次将区间缩小至原来的二分之一.。设f(x)为下单峰函数,若f(x)在[a,b]具有连续的一阶导数,且f ’(a)<0, f ’(b)>0。 取 c=(a+b)/2,若f’©=0,则c为极小点; 若f ’©>0,则以[a,c]代替[a,b]作为新区间; 若f ’©<0,则以[c,b]代替[a,b]作为...
快速排序的二分优化法
CAOSHUCAOSHU的博客
12-04 450
普通的快速排序代码： int partition1(int a[],int left,int right){ int p=(int)round(1.0*rand()/RAND_MAX*(right-left)+left); swap(a[p],a[left]); int temp=a[left]; while(left<right){ while(left<right&&a[right]>temp) right--;
线性查找与优化-二分法
weixin_61639290的博客
11-15 1214
这是我第一篇分享，纪念一下； 线性查找，也叫线性搜索： 我的理解就是在一个数组里面查找你想要的那个数字的下标，如果没有咱们以返回-1来表示； 思路： 遍历整个数组，一个for循环结束，输出所需要的下标 代码如下： #include <stdio.h> int search(int k,int len,int a[])//搜索函数，k是我们要找的数，len是不确定的数组长度，a[]是我们的数组 { int i; int r=-1;//如果没有就是-1 for
最优化方法Python计算：一元函数搜索算法——二分法
u012958850的博客
05-03 2134
一元函数二分搜索算法的实现
算法性能优化之二分法与二次问题
叮当猫的博客
02-10 863
性能优化小案例 1、二分法查找 有序数组查找 有序数组是什么？ 如果一个数组中的值是按一定顺序排列的，我们就称为有序数组 例如：数组 [2, 8, 15, 24, 66, 88, 100] 现在希望完成一个函数来实现：查找某个数字是否存在数组中。例如： 24 存在数组中，索引值是 3，1000 不在数组中 线性查找 方法一：我们使用暴力查找方法，通过遍历整个数组来判定该数字是否存在 public static int orangeFind(int[] array, int aim) { fo
【算法】—二分法详解
热门推荐
DAY I 的成长之路
03-28 1万+
在计算机科学中，二分查找算法也称折半搜索算法，对数搜索算法，是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半，时间复杂度是log(n)二分法的步骤：我们要在一组升序的数组找一个数的下标，那我们肯定是先拿中间的与他进行比较，比较大小的判断，其实
二分法（一篇文章讲透）
2303_79387663的博客
03-18 5473
二分法作为一种简单而有效的数值求解方法，在各个领域都有着广泛的应用。通过深入理解其基本原理、实现步骤和优化策略，我们可以更好地利用二分法来解决实际问题。未来，随着计算机技术的不断发展，我们有望看到更多基于二分法的创新应用和优化算法的出现。
掌握牛顿-二分法：数值计算与源码解析
资源摘要信息:"Newton_erfen.rar_newton_二分法" 知识点： 1. 牛顿法（Newton's Method）： 牛顿法，又称为牛顿-拉弗森方法（Newton-Raphson method），是一种在实数域和复数域上近似求解方程的方法。牛顿法使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值