算法篇-二分搜索-基础到实战

于 2023-10-24 14:54:51 发布
阅读量68 收藏
点赞数
文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57654074/article/details/134012381
版权

title: 算法篇-二分搜索
date: 2023-4-10 20:12:57
categories:

  • 算法
    tags:
  • Java
  • 计算机基础
  • 数据结构
  • 算法
  • 二分搜索

参考：

  • 个人网站:www.huangrd.top
  • 力扣windliang：https://leetcode.cn/problems/search-a-2d-matrix-ii/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-5-4/
  • 力扣Krahets：https://leetcode.cn/leetbook/read/illustration-of-algorithm/5dj09d/
  • 代码随想录：https://programmercarl.com/

二分搜索

基础概述

Binary Search

对于已经有序的数组，使用二分搜索加快搜索速度

时间复杂度O(log N)

  1. 有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时，查找成功需要比较的次数

  2. 使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时，需要经过?次比较

  3. 在拥有128个元素的数组中二分查找一个数，需要比较的次数最多不超过多少次

对于前两个题目，记得一个简要判断口诀：奇数二分取中间，偶数二分取中间靠左。对于后一道题目，需要知道公式：

n = log2 N = log_{10}N/log_{10}2

其中 n 为查找次数，N 为元素个数

二分法的两种写法：

  • 左闭右闭[left,right]
  • 左闭右开[left,right)

左闭右闭

target 是在一个在左闭右闭的区间里，[left, right] 。

对于左闭右闭的写法：

  • while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
  • if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

二分法

/**
 * 左闭右闭
 */
public int binarySearch1(int[] nums, int target) {
    int left = 0;
    int right = nums.length - 1;//区间[left，right]要有意义
    while (left <= right) {//注意点1
        int mid = left + ((right - left) / 2);//防止溢出
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else return mid;
    }
    return -1;
}

左闭右开

定义 target 是在一个在左闭右开的区间里，也就是[left, right)。

对于左闭右开的写法：

  • while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
  • if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

在这里插入图片描述

/**
 * 左闭右开
 * */
public int binarySearch2(int[] nums, int target) {
    int left = 0;
    int right = nums.length;//区间[left,right)
    while (left < right) {
        int mid = left + ((right - left) / 2);
        if (nums[mid] < target) {//左闭
            left = mid + 1;
        } else if (nums[mid] > target) {//右开
            right = mid;
        } else return mid;
    }
    return -1;
}

二分法查找左右边界

public static int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

public static int binarySearchFindLeft(int[] nums, int target) {
    int left = 0, right = nums.length;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else {
            // 不返回，收缩右边界，找到左侧边界 合并 > 情况
            right = mid;
        }
    }
    return left != nums.length && nums[left] == target ? left : -1;
}

public static int binarySearchFindRight(int[] nums, int target) {
    int left = 0, right = nums.length;
    while (left < right) {
        // 不返回，收缩左边界，找到左右侧边界
        int mid = left + (right - left) / 2;
        if (nums[mid] <= target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left != 0 && nums[left - 1] == target ? left - 1 : -1;
}

public static void main(String[] args) {
    int[] nums = {1, 5, 8, 11, 19, 19, 19, 22, 31, 35, 40, 45, 48, 49, 50};
    System.out.println(binarySearchFindLeft(nums, 19));
    System.out.println(binarySearch(nums, 19));
    System.out.println(binarySearchFindRight(nums, 19));
}

力扣

LC69. x 的平方根

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

**注意：**不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

利用二分法的思路，在0~x-1中搜索出他的平方根，排除特例。

public int mySqrt(int x) {
    /**
     * 二分查找
     * [left,right)
     * */
    //因为定义的区间为左闭右开，对于x，当x < 2的时候，x才会取0 or x 即 0 1
    if (x < 2) return x;
    int left = 1;
    int right = x;
    while (left < right) {
        int mid = left + ((right - left) / 2);
        if (mid > x / mid) {
            //mid > x / mid防止溢出
            right = mid;
        } else if (mid < x / mid) {
            left = mid + 1;
        } else return mid;
    }
    return right - 1;
}

面试题目要求：求某正整数的平方根，要求误差小于0.01

//二分法进行处理，注意变量类型
 public static double sqrt(int target){
        double n=1e-2;            //在这里可根据精度要求进行调整
        double l=0,r=target;      //这里若初始化r=target/2的话，则处理较小正整数会出错，如1,2
        while(l<=r){              //二分查找
            double mid=(l+r)/2;
            //这里用除法，而不用mid*mid与target比较，是防止mid过大时，mid*mid产生溢出问题
            if(target/mid<mid){   
                r=mid-n;
            }else{
                l=mid+n;
            }
        }
        return r;
    }
}

LC367. 有效的完全平方数

给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

进阶：不要 使用任何内置的库函数，如 sqrt 。

防止越界，用long表示。

/**
* 二分法
* [left,right]左闭右闭
* */
public boolean isPerfectSquare(int num) {
    int left = 0;
    int right = num;
    while (left <= right) {
        int mid = left + ((right - left) / 2);
        long square = (long) mid * mid;
        if (square > num) {
            right = mid - 1;
        } else if (square < num) {
            left = mid + 1;
        } else{
            return true;
        }
    }
    return false;
}

LC1802. 有界数组中指定下标处的最大值

给你三个正整数 n、index 和 maxSum 。你需要构造一个同时满足下述所有条件的数组 nums（下标 从 0 开始 计数）：

  • nums.length == n
  • nums[i] 是 正整数 ，其中 0 <= i < n
  • abs(nums[i] - nums[i+1]) <= 1 ，其中 0 <= i < n-1
  • nums 中所有元素之和不超过 maxSum
  • nums[index] 的值被 最大化

返回你所构造的数组中的 nums[index] 。

注意：abs(x) 等于 x 的前提是 x >= 0 ；否则，abs(x) 等于 -x 。

示例 1：

输入：n = 4, index = 2,  maxSum = 6
输出：2
解释：数组 [1,1,2,1] 和 [1,2,2,1] 满足所有条件。不存在其他在指定下标处具有更大值的有效数组。

示例 2：

输入：n = 6, index = 1,  maxSum = 10
输出：3

提示：

  • 1 <= n <= maxSum <= 109
  • 0 <= index < n

Related Topics

贪心

二分查找

👍 81

👎 0

根据题目描述，如果我们确定了 nums[index] 的值为 x，此时我们可以找到一个最小的数组总和。也就是说，在 index 左侧的数组元素从 x-1 每次递减 1，如果减到 1 后还有剩余元素，那么剩余的元素都为 1；同样的，在 index 及右侧的数组元素从 x 也是每次递减 1，如果减到 1 后还有剩余元素，那么剩余的元素也都为 1。

这样我们就可以计算出数组的总和，如果总和小于等于 maxSum，那么此时的 x 是合法的。随着 x 的增大，数组的总和也会增大，因此我们可以使用二分查找的方法，找到一个最大的且符合条件的 x。

为了方便计算数组左侧、右侧的元素之和，我们定义一个函数 sum(x, cnt)，表示一共有 cnt 个元素，且最大值为 x 的数组的总和。函数 sum(x, cnt) 可以分为两种情况：

计算[0,idx] 和 [idx, n - 1]区间所有元素的和
设cnt为区间的元素个数，即idx + 1 或 n - idx
1. cnt >= x, 那么会有多余的数全部放置为1: cnt - mid, 剩下的数为1,2,...x, 和为(x+1)*x/2。  
总和 = cnt - x + (x+1)*x/2
2. cnt < x, 那么放置的数为 x - cnt + 1, x - cnt, ...., x即[x-cnt+1, x],
总和 = (2x-cnt+1) * cnt / 2

  • 如果 x ≥ cnt，那么数组的总和为 [(x+x−cnt+1)×cnt]/2

  • 如果 x < cnt，那么数组的总和为 [(x+1)×x]/2+cnt−x

对于满足条件的最大的 x，x+1，x+2,… 一定不满足条件，而 1,2,…,x 这些数都满足条件，我们需要寻找最大的x，由于 n=10^9, 直接循环肯定不行，我们使用二分查找来寻找满足条件的最大x。

接下来，定义二分的左边界 left = 1，右边界 right = maxSum，然后二分查找 nums[index] 的值 mid，如果 sum(mid−1,index) + sum(mid,n−index) ≤ maxSum，那么此时的 mid 是合法的，我们可以将 left 更新为 mid，否则我们将 right 更新为 mid - 1。

最后将 left 作为答案返回即可。

class Solution {
    public int maxValue(int n, int index, int maxSum) {
        int left = 1, right = maxSum;
        while (left < right) {
            // 当用到的是r=mid是，就是mid=l+r>>1,当用到的是l=mid时，就是mid=l+r+1>>1,这是别人总结出来的经验，这样就避免了出现各种各样的边界错误。
            int mid = (left + right + 1) >>> 1;
            if (sum(mid - 1, index) + sum(mid, n - index) <= maxSum) {
                left = mid;
            } else {
                right = mid - 1;
            }
        }
        return left;
    }

    private long sum(long x, int cnt) {
        return x >= cnt ? (x + x - cnt + 1) * cnt / 2 : (x + 1) * x / 2 + cnt - x;
    }
}

复杂度分析：

  • 时间复杂度 O*(logN)*
  • 空间复杂度 O(1)。其中 N = maxSum

LC33. 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

示例 3：

输入：nums = [1], target = 0
输出：-1

提示：

  • 1 <= nums.length <= 5000
  • -104 <= nums[i] <= 104
  • nums 中的每个值都 独一无二
  • 题目数据保证 nums 在预先未知的某个下标上进行了旋转
  • -104 <= target <= 104

Related Topics

数组

二分查找

👍 2442

👎 0

解题思路：

先根据 nums[mid] 与 nums[left] 的关系判断 mid 是在左段还是右段，接下来再判断 target 是在 mid 的左边还是右边，从而来调整左右边界 left 和 right。

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while (left <= right) { // [,]左闭右闭
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            }
            // 先根据 nums[mid] 与 nums[left] 的关系判断 mid 是在左段还是右段
            if (nums[mid] >= nums[left]) {
                // 再判断 target 是在 mid 的左边还是右边，从而调整左右边界 left 和 right
                if (target < nums[mid] && target >= nums[left]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                if (target > nums[mid] && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        return -1;
    }
}

复杂度分析：

  • 时间复杂度O(log N)
  • 空间复杂度O(1)

LC240. 搜索二维矩阵 II

编写一个高效的算法来搜索 *m* x *n* 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

  • 每行的元素从左到右升序排列。
  • 每列的元素从上到下升序排列。

示例 1：

在这里插入图片描述

输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5
输出：true

示例 2：

在这里插入图片描述

输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20
输出：false

提示：

  • m == matrix.length
  • n == matrix[i].length
  • 1 <= n, m <= 300
  • -109 <= matrix[i][j] <= 109
  • 每行的所有元素从左到右升序排列
  • 每列的所有元素从上到下升序排列
  • -109 <= target <= 109

Related Topics

数组

二分查找

分治

矩阵

👍 1251

👎 0

方法一 逐行二分

逐行进行二分搜索，根据有序性:

  • 当某一行第一个元素 > target，则没找到 target, 结束。
  • 当某一行最后一个元素 < target，则改行没有 target, 下一行继续。
class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }

        for (int i = 0; i < matrix.length; i++) {
            // 1. 第一个元素大于tar
            if (matrix[i][0] > target) {
                return false;
            }
            // 2. 最后一个元素小于tar
            if (matrix[i][matrix[i].length - 1] < target) {
                continue;
            }
            if (binarySearch(matrix[i], target) != -1) {
                return true;
            }
        }
        return false;
    }

    private int binarySearch(int[] matrix, int target) {
        int left = 0, right = matrix.length - 1;
        while (left <= right) {
            int mid = left + right >> 1;
            if (matrix[mid] == target) {
                return mid;
            } else if (matrix[mid] > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
}

复杂度分析

  • 时间复杂度 O(M * log N)
  • 空间复杂度 O(1)

方法二 二分查找数

从右上角出发开始遍历，会发现每次都是向左数字会变小，向下数字会变大，有点和 二分查找树 相似。二分查找树的话，是向左数字变小，向右数字变大。

所以我们可以把 target 和当前值比较。

  • 如果 target 的值大于当前值，那么就向下走。
  • 如果 target 的值小于当前值，那么就向左走。
  • 如果相等的话，直接返回 true 。

也可以换个角度思考:

如果 target 的值小于当前值，也就意味着当前值所在的列肯定不会存在 target 了，可以把当前列去掉，从新的右上角的值开始遍历。

同理，如果 target 的值大于当前值，也就意味着当前值所在的行肯定不会存在 target 了，可以把当前行去掉，从新的右上角的值开始遍历。

[1,   4,  7, 11, 15],
[2,   5,  8, 12, 19],
[3,   6,  9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]

如果 target  = 9，如果我们从 15 开始遍历, cur = 15
    
target < 15, 去掉当前列, cur = 11
[1,   4,  7, 11],
[2,   5,  8, 12],
[3,   6,  9, 16],
[10, 13, 14, 17],
[18, 21, 23, 26]    
    
target < 11, 去掉当前列, cur = 7  
[1,   4,  7],
[2,   5,  8],
[3,   6,  9],
[10, 13, 14],
[18, 21, 23]     

target > 7, 去掉当前行, cur = 8   
[2,   5,  8],
[3,   6,  9],
[10, 13, 14],
[18, 21, 23]       

target > 8, 去掉当前行, cur = 9, 遍历结束    
[3,   6,  9],
[10, 13, 14],
[18, 21, 23]   

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int row = 0, col = matrix[0].length - 1;
        while (row < matrix.length && col >= 0) {
            if (target == matrix[row][col]) {
                return true;
            } else if (target < matrix[row][col]) {
                col--;
            } else {
                row++;
            }
        }
        return false;
    }
}

复杂度分析：

  • 时间复杂度：O(M + N)
  • 空间复杂度：O(1)

方法三 二维二分

找到矩阵的中心，然后和目标值比较看能不能丢弃一些元素。

如下图，中心位置是 9
[1,   4,  7, 11, 15],
[2,   5,  8, 12, 19],
[3,   6, /9/,16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]

通过中心位置, 我们可以把原矩形分成四个矩形, 左上, 右上, 左下, 右下
[1,   4,  7         [11, 15  
 2,   5,  8          12, 19  
 3,   6, /9/]        16, 22] 
 
[10, 13, 14         [17, 24
18, 21, 23]          26, 30]

如果 target = 10,
此时中心值小于目标值，左上角矩形中所有的数都小于目标值，我们可以丢弃左上角的矩形，继续从剩下三个矩形中寻找

如果 target = 5,
此时中心值大于目标值，右下角矩形中所有的数都大于目标值，那么我们可以丢弃右下角的矩形，继续从剩下三个矩形中寻找

在这里插入图片描述

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        return searchMatrixHelper(matrix, 0, 0, matrix[0].length - 1, matrix.length - 1, matrix[0].length - 1, matrix.length - 1, target);
    }

    private boolean searchMatrixHelper(int[][] matrix, int x1, int y1, int x2, int y2, int xMax, int yMax, int target) {
        //只需要判断左上角坐标即可
        if (x1 > xMax || y1 > yMax) {
            return false;
        }

        // x表示列，y表示行
        if (x1 == x2 && y1 == y2) {
            return target == matrix[y1][x1];
        }

        int m1 = (x1 + x2) >>> 1;
        int m2 = (y1 + y2) >>> 1;
        if (matrix[m2][m1] == target) {
            return true;
        }

        if (matrix[m2][m1] < target) {
                    // 右上矩阵
            return searchMatrixHelper(matrix, m1 + 1, y1, x2, m2, x2, y2, target) ||
                    // 左下矩阵
                    searchMatrixHelper(matrix, x1, m2 + 1, m1, y2, x2, y2, target) ||
                    // 右下矩阵
                    searchMatrixHelper(matrix, m1 + 1, m2 + 1, x2, y2, x2, y2, target);

        } else {
                    // 右上矩阵
            return searchMatrixHelper(matrix, m1 + 1, y1, x2, m2, x2, y2, target) ||
                    // 左下矩阵
                    searchMatrixHelper(matrix, x1, m2 + 1, m1, y2, x2, y2, target) ||
                    // 左上矩阵
                    searchMatrixHelper(matrix, x1, y1, m1, m2, x2, y2, target);
        }
    }
}

复杂度分析：

  • 时间复杂度：O(n(log_43)),大约n^0.8.

LC34. 在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

提示：

  • 0 <= nums.length <= 105
  • -109 <= nums[i] <= 109
  • nums 是一个非递减数组
  • -109 <= target <= 109

Related Topics

数组

二分查找

👍 2255

👎 0

先查找左边界，再从左边界向后二分查找右边界。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        // 先找最左边位置
        int left = binarySearchLeft(nums, target);
        if (left == -1) {
            return new int[]{-1, -1};
        }
        // 再找最右边的位置
        int right = binarySearchRight(nums, left, target);
        return new int[]{left, right};
    }

    private int binarySearchRight(int[] nums, int left, int target) {
        int right = nums.length;
        while (left < right) {
            int mid = left + ((right - left) >>> 1);
            if (nums[mid] <= target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return left != 0 && nums[left - 1] == target ? left - 1 : -1;
    }

    private int binarySearchLeft(int[] nums, int target) {
        int left = 0, right = nums.length;
        while (left < right) {
            int mid = left + ((right - left) >>> 1);
            if (nums[mid] < target) {
                left = mid + 1;
            } else {
                right = mid;
            }
        }
        return left != nums.length && nums[left] == target ? left : -1;
    }
}

复杂度分析：

  • 时间复杂度：O(log N)
  • 空间复杂度：O(1)
HaungRD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二分搜索问题大汇总
weixin_42379358的博客
07-23 441
p划分问题 p划分问题转载自：这位大佬的 手把手教你写出正确的二分搜索。 这篇博客将二分搜索自成体系地总结了为了以下七个问题，以p划分作为问题共性，而且居然写出了证明，非常值得一看。 为了更好地理解p划分，我将这七个问题再以自己的方式总结一遍。 理解p划分 p划分指，此处有一个条件p，当条件p能将一个数组划分为两边，左半边和右半边刚好是相对条件p来说是对立的。这时，我们称这个数组是p划分的。 那么一般情况下，只有当数组有序时，才会出现p划分的情况。举例来说：在数组a=[1,2,3,4,5]中，如果以a[i]
二分搜索题目总结
maple的博客
05-21 308
二分搜索
详解二分搜索算法
qq_43460883的博客
11-26 1745
我周围的人几乎都认为二分查找很简单，但事实真的如此吗？二分查找真的很简单吗？并不简单。看看 Knuth 大佬（发明 KMP 算法的那位）怎么说的： Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky… 这句话可以这样理解：思路很简单，细节是魔鬼。 本文就来探究几个最常用的二分查找场景：寻找一个数、寻找左侧边界、寻找右侧边界。 而且，我
【详解】二分查找
陈戏猿
07-02 765
二分查找的思量非常简单，但是要写对也不是件容易事。二分搜索的主要矛盾在于存在重复值的情况，因为这种情况下涉及到查找方向的问题，也既是返回最左边的值的位置，还是最右边的值的位置，还是随便一个值的位置。本文将详细讲解二分查找算法的全部细节，帮你真正理解二分查找算法的精髓，从此告别死记硬背。......
算法笔记：二分查找
凭心而动
02-10 9689
二分查找的概念、一般操作步骤、二分查找的模板、二分查找相关的算法题目以及详细的代码实现及思路和代码释义
贝叶斯算法-实战：新闻分类器
06-18
在本项目中，我们将深入探讨"贝叶斯算法-实战：新闻分类器"这一主题，这是一个非常适合机器学习初学者的实践项目。通过这个项目，你可以了解到如何利用贝叶斯算法来处理文本分类问题，特别是新闻文章的分类。下面将...
字符识别-基于Swin-Transformer实现的OCR字符识别算法-附项目源码-优质项目实战.zip
04-29
在这个名为“字符识别-基于Swin-Transformer实现的OCR字符识别算法-附项目源码-优质项目实战.zip”的压缩包中，包含了一个高质量的实践项目，该项目专注于使用Swin-Transformer这一先进的深度学习模型来实现OCR...
算法部署-使用TVM编译优化部署Gluon-cv模型-附项目源码-优质项目实战.zip
最新发布
06-06
在IT行业中，算法部署是将训练好的机器学习或深度学习模型投入实际应用的关键步骤。本项目专注于使用TVM（Tensor Virtual Machine）进行模型编译优化，以高效地部署基于Gluon-CV库构建的计算机视觉模型。TVM是一个...
算法笔记-上机训练实战指南-胡凡
07-27
本书涵盖了丰富的算法类型，包括但不限于排序算法（如冒泡排序、快速排序、归并排序、堆排序等）、搜索算法（如二分查找、深度优先搜索、广度优先搜索等）、图论算法（如最短路径算法Dijkstra、最小生成树Prim和...
机器学习算法基础-覃秉丰 课件+ 代码
07-23
【机器学习算法基础】课程由覃秉丰教授主讲，主要涵盖了机器学习的基本概念、原理以及常见算法的应用。课程旨在帮助初学者理解机器学习的核心思想，并通过实际代码实现加深对算法的理解。 一、机器学习概览 机器...
面试经典------二分搜索问题
qq_43599511的博客
04-23 233
数据结构与算法学习笔记之二分搜索二分搜索的优缺点二分搜索的实现方法二分搜索的面试题种类及解题思路 二分搜索的优缺点 二分搜索（折半搜索）的Wikipedia定义：是一种在有序数组中查找某一特定元素的搜索算法。从定义可知，运用二分搜索的前提是数组必须是排好序的。另外，输入并不一定是数组，也有可能是给定一个区间的起始和终止的位置。 优点：搜索速度快，时间复杂度为O（logn），即对数时间，也称为对数查...
面试中几种常见的二分查找问题及解题模板总结
sym的博客
06-05 432
二分查找问题，想必对于开发人员来说都不陌生，但是想要准确而又熟练地写出二分查找及其变形问题的算法代码，对许多人来说，可能并不是一件很容易的事。 二分查找几种变形 二分查找，又称为⼆分搜索，一般有 以下几种变形题： 1. 查找第⼀次出现的等于给定目标值的元素（或元素下标） 2. 查找最后一次出现的等于给定目标值的元素（或元素下标） 3. 查找第⼀个⼤于等于给定值的元素（或元素下标） 4. 查找最后⼀个⼩于等于给定值的元素（或元素下标） 5. 查找给定目标值出现的起始和终止元素对应的位置（第1和第2种类型的结合
数组查找最大元素方法
weixin_37672398的博客
02-27 445
static int searchMaxValueInArray(int[] array){ int i = 0; for(i = 0;i if(array[i] > array[i + 1]){ int t = 0; t = array[i]; array[i] = array[i + 1]; array[i + 1] = t; } } return array[i];
二分搜索算法解题步骤，吐血整理
月伴飞鱼
11-25 4987
基本介绍 二分搜索（折半搜索）是一种在有序数组中查找某一特定元素的搜索算法。从定义可知，运用二分搜索的前提是数组必须是排好序的。另外，输入并不一定是数组，也有可能是给定一个区间的起始和终止的位置。 他的时间复杂度是 O(lgn)，非常高效。 特点 他的缺点要求待查找的数组或者区间是排好序的。 对数组进行动态的删除和插入操作并完成查找，平均复杂度会变为 O(n)。 因此，当输入的数组或者区间是排好序的，同时又不会经常变动，而要求从里面找出一个满足条件的元素的时候，二分搜索就是最好的选择。 解题思路 二分搜索一
二分搜索(查找)方法
热门推荐
这个杀手不太累的博客
04-26 1万+
搜索：就是在数组中寻找一个指定元素的过程。例如：查找一个商品价格列表中指定价格的商品。 在讨论二分搜索方法前先说下顺序搜索：顺序搜索 将关键字key顺序地与数组中每个元素进行比较，这个过程一直持续下去，直至关键字与某个元素匹配，或者所有数组元素都已比较完毕。 int linearSearch(int list[],int key,int arraySize) { for(int i = 0;
二分查找的典型问题（三）：判别条件复杂的二分查找问题
Roxannekkk的博客
10-21 490
目标变量和另一个变量有相关关系（一般而言是线性关系），目标变量的性质不好推测，但是另一个变量的性质相对容易推测。这样的问题的判别函数通常会写成一个函数的形式。 例题一 分析：题目中说，最小速度 K 是一个整数，并且我们知道这个 K 不可能无限大，珂珂一个小时能吃的香蕉最多为一整堆香蕉的个数。因此 K 是一个有范围的整数。如果我们做多了二分查找的问题，就知道这样的问题可以考虑使用二分查找去做，事实上，这道问题的解题思路就是我们在上一节介绍过的「二分答案」。 根据题意，我们不难分析出，如果珂珂每个小时吃的香蕉
二分搜索详解
weixin_52445683的博客
03-15 639
讲述了递归结构和非递归结构的二分搜索处理方式。
二分搜索算法 (binary search)
TheAnnoyingDog的博客
02-15 4422
二分搜索算法 二分的本质并不是单调性，但是具有单调性一定可以使用二分，可以使用二分不一定具有单调性。二分的要点是"边界问题" 二分算法看似很容易实现，但是对于处理二分的边界上的细节时却十分复杂。 所以使用二分算法之前需要根据实际问题进行建模，根据不同的性质设置判断条件，划分红蓝区域，最终定位边界。 请看下图： 找出蓝色的边界的数字和红色边界的数字。 可以将图中的一串数字根据颜色的不同，而划分成红蓝两个区域，可以使用通过二分法来确定红蓝区域的边界。 两头分别设立两个指针，l 和 r ，l 是从左相向右扫描
二分查找问题以及常见的二分查找变种问题
qq_42006733的博客
02-26 1628
二分查找 二分查找又叫做折半查找，二分查找针对的是一个有序的数据集合，查找思想有点类似分治思想。 每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0。 查找效率 假设数据大小是 n，每次查找后数据都会缩小为原来的一半，也就是会除以 2。最坏情况下，直到查找区间被缩小为空，才停止。 那么被查找的区间变化就是：n，n/2，n/4，...
数据结构与算法 全 数据结构与算法全 Java
03-04
- **二分查找** 是一种高效的搜索算法，适用于已排序的数组。它通过不断缩小搜索范围来找到目标值，分为基础版、改变版和平衡版。Java中实现二分查找可以提高搜索效率。 **二. 基础数据结构** - **数组** 是最基础...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值