搞定leetcode面试经典150题之二分查找

已于 2024-12-20 16:00:58 修改
阅读量706 收藏 7
点赞数 21
CC 4.0 BY-SA版权
分类专栏： LeetCode刷题 文章标签： leetcode 面试 算法
于 2024-12-16 20:51:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/buyaotutou/article/details/144500506

系列博客目录

文章目录

理论知识

二分查找（Binary Search）是一种在已排序的数组或列表中查找特定元素的高效算法，其基本思想是每次将查找范围缩小一半，从而显著减少查找时间。

基本理论：

  1. 前提条件：二分查找要求数组必须是已排序的（升序或降序都可以）。
  2. 过程：通过比较目标值与数组中间元素的大小关系，决定是继续在左半部分查找，还是继续在右半部分查找。
    • 若目标值小于中间元素，则目标值只可能在中间元素的左侧。
    • 若目标值大于中间元素，则目标值只可能在中间元素的右侧。
  3. 结束条件：当查找区间缩小到一个元素时，如果该元素等于目标值，则查找成功；如果该元素不等于目标值，且区间无法继续缩小，则查找失败。

算法步骤：

假设目标元素是target，数组是arr，长度是n，二分查找的算法可以分为以下几个步骤：

  1. 初始化查找区间的左右边界：left = 0，right = n - 1。
  2. 进入循环，判断当前区间是否有效：left <= right。
  3. 计算中间位置：mid = (left + right) / 2。
  4. 判断目标值与中间元素的大小：
    • 若 arr[mid] == target，则查找成功，返回mid。
    • 若 arr[mid] > target，则继续在左半部分查找：right = mid - 1。
    • 若 arr[mid] < target，则继续在右半部分查找：left = mid + 1。
  5. 如果退出循环（查找失败），则返回未找到的标志。

二分查找的时间复杂度：

  • 时间复杂度：O(log n)，其中n是数组的长度。每次查找都将查找区间缩小一半，因此查找的次数是对数级别的。
  • 空间复杂度：O(1)（对于迭代实现），因为只需要常量空间存储left、right和mid等变量。

二分查找的变种：

  • 查找第一个等于目标值的元素：如果有多个相同的元素，可以通过修改判断条件，使其找到第一个符合条件的元素。
  • 查找最后一个等于目标值的元素：同样可以修改判断条件，找到最后一个符合条件的元素。

注意事项：

  • 二分查找只能在已排序的数组上进行，未排序的数组需要先排序。
  • 在实现时，特别要注意整数溢出的情况，mid可以通过mid = left + (right - left) / 2来计算，而不是直接mid = (left + right) / 2，避免因left和right很大时相加导致溢出。

模板

在这里插入图片描述

public static int findLeftEq(int[] arr, int num) {
    int l = 0;
    int r = arr.length - 1;
    int res = -1;
	int m = 0;
    while (l <= r) {
        m = l + ((r - l) >> 1); // 计算中间索引，避免溢出
        if (arr[m] == num) {
            res = m; // 找到目标值，记录位置
            r = m - 1; // 继续向左半边查找，确保找到第一个等于目标的元素
        } else if (arr[m] > num) {
            r = m - 1; // 目标值在左半边
        } else {
            l = m + 1; // 目标值在右半边
        }
    }
    return res; // 返回结果，若未找到目标值，返回 -1
}

例题

35.搜索插入位置

链接

利用下面第34题中的代码和思想，寻找大于等于target的最左边的位置。通过res来记录符合条件的坐标。给res赋初值为nums.length，正好可以如果数组中所有的值都比target小，target就应该插入到nums.length的位置。

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length -1;
        int mid = 0;
        int res = nums.length;
        while(left <= right){
            mid = left + ((right - left) >> 1);
            if(nums[mid] >= target){
                res = mid;
                right = mid - 1;//通过移动右指针，不断往左寻找更合适的下表
            }else {
                left = mid + 1;
            }
        }
        return  res;
    }
}

74.搜索二维矩阵

链接
思路：对二维矩阵第一维进行二分查找，我们只在移动左指针时候更新存储target所在行的res。因为右指针肯定不对，其第0个元素都比target大，那后面元素肯定更大。我们不断更新res，到了最后一次在左指针更新res的时候，我们通过res保存了左指针，之后左指针变化但是没有找到target，也就是说如果后面找不到matrix[mid][0] == target，它只可能在第res行(left的上一次所指向的行)中。

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int right = matrix.length - 1;
        int left = 0;
        int mid = 0;
        int res = 0;
        while(left <= right){
            mid = left + ((right - left) >> 1);
            if(matrix[mid][0] == target){
                res = mid;
                return true;
            } else if (matrix[mid][0] < target) {
                res = mid;
                //因为target只能存在matrix[mid][0] < target所在的第m行中，我们不断更新res
                //如果之后没有找到target（matrix[mid][0] == target），也就是说其在res所存的第m行中，其右边没有比这更可能满足的情况。
                left = mid + 1;//注意上面已经保存了mid，这时候left=mid+1，而不是left = mid；不要想着此时的mid可能就符合最后的res，就不舍得left跳过他，他已经被res保存，不会错过。
            }else {
                right = mid - 1;
            }
        }
        int[] line = matrix[res];
        left = 0;
        right = line.length - 1;
        mid = 0;
        while(left <= right){
            mid = left + ((right - left) >> 1);
            if(line[mid] == target) return true;
            else if(line[mid] < target){
                left = mid +1;
            }else {
                right = mid - 1;
            }
        }
        return false;
    }
}

162.寻找峰值

链接
写下面的代码需要先定好compare是如何比较的，比如是拿第一个参数和第二个参数比大小，第一个大就输出>0(两个参数相减)。再对后面的三位运算符进行编程。

class Solution {
    public int findPeakElement(int[] nums) {
        int n = nums.length;
        int idx = (int)(Math.random()*n);
        while(!(compare(nums, idx - 1 ,idx) < 0 &&compare(nums, idx, idx + 1) > 0)){
            if(compare(nums, idx-1, idx)>0){
                idx --;
            }else {
                idx ++;
            }
        }
        return idx;
    }
    public int[] get(int[] nums, int idx){
        if(idx == -1 || idx == nums.length){
            return new int[]{0,0};
        }
        return new int[]{1,nums[idx]};
    }
    public int compare(int[] nums, int idx1, int idx2){
        int[] num1 = get(nums, idx1);
        int[] num2 = get(nums, idx2);
        if(num1[0] != num2[0]){
            return num1[0] < num2[0] ? -1 : 1;
        }
        if (num1[1] == num2[1]) return 0; //这行代码可以去掉
        else return num1[1] > num2[1] ? 1 : -1;
    }
}

加入二分查找后，达到时间复杂度要求

class Solution {
    public int findPeakElement(int[] nums) {
        int n = nums.length;
        int left = 0, right = n - 1, ans = -1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (compare(nums, mid - 1, mid) < 0 && compare(nums, mid, mid + 1) > 0) {
                ans = mid;
                break;
            }
            if (compare(nums, mid, mid + 1) < 0) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return ans;
    }

    // 辅助函数，输入下标 i，返回一个二元组 (0/1, nums[i])
    // 方便处理 nums[-1] 以及 nums[n] 的边界情况
    public int[] get(int[] nums, int idx) {
        if (idx == -1 || idx == nums.length) {
            return new int[]{0, 0};
        }
        return new int[]{1, nums[idx]};
    }

    public int compare(int[] nums, int idx1, int idx2) {
        int[] num1 = get(nums, idx1);
        int[] num2 = get(nums, idx2);
        if (num1[0] != num2[0]) {
            return num1[0] > num2[0] ? 1 : -1;
        }
        if (num1[1] == num2[1]) {//这个if判断可以去掉
            return 0;
        }
        return num1[1] > num2[1] ? 1 : -1;
    }
}

作者：力扣官方题解
链接：https://leetcode.cn/problems/find-peak-element/solutions/998152/xun-zhao-feng-zhi-by-leetcode-solution-96sj/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

33.搜索旋转排序数组

链接
在这里插入图片描述
数组经过旋转后，变成了两部分，如果nums[mid]它大于nums[nums.length-1],说明mid在左部分，如果target也在mid左边的话我们就可以把right指针移动(过来到mid左边)，现在left指针和right指针都在左部分了，再在左部分(现在left指针和right指针中的值递增了）中利用二分查找。如果target不在，那就只能把left指针移动到mid左边，这时候可能left指针与right指针中间还是有两部分序列，并不严格递增，再进行下一次判断。

class Solution {
    public int search(int[] nums, int target) {
        int right = nums.length - 1;
        int left = 0;
        while(left <= right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid] == target){
                return mid;
            } else if (nums[mid] < nums[right]) {
                if(nums[mid] < target && nums[right] >= target){
                    left = mid +1;
                }else {
                    right = mid -1;
                }
            }
            else {
                if(nums[mid] > target && target >= nums[left]){
                    right = mid -1;
                }else {
                    left =mid +1;
                }
            }
        }
        return -1;
    }
}

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

链接
比如target为8，我们要找到大于等于8的最左边的位置和小于等于8的最右边的位置。注意不一定有target存在于数组中。
在这里插入图片描述

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums.length == 0){
            return new int[]{-1, -1};
        }
        int left = 0;
        int right = nums.length - 1;
        int mid = 0;
        int res = -1;
        while(left<=right){
            mid = left + ((right - left) >> 2);
            if(nums[mid] == target){//满足大于等于target，保存位置，用于后续判定
                res = mid;
                right = mid - 1;
            } else if (nums[mid] > target) {//满足大于等于target，保存位置，用于后续判定
                res = mid;
                right = mid - 1;
            }else {
                left = mid + 1;
            }
        }
        int res_left = res;
        left = 0;
        right = nums.length - 1;
        mid = 0;
        res = -1;
        while(left<=right){
            mid = left + ((right - left) >> 2);
            if(nums[mid] == target){
                res = mid;
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid - 1;
            }else {
                res = mid;
                left = mid + 1;
            }
        }
        int res_right = res;
        if(res_left <= res_right && res_right != -1&& res_left != -1 && nums[res_left] == target && nums[res_right] == target ){
            return new int[]{res_left, res_right};
        }

        return new int[]{-1, -1};
    }
}

153.寻找旋转排序数组中的最小值

链接
根据上题的思路，我们现在是要找比nums[mid]小的值，但与之前存在不同。我们还是认为此时数组由两个递增的部分组成，也就是说如果当前位置的值，比右指针小，那当前位置和右指针都在同一部分，而又因为当前比右指针小，所以右指针可以移动到当前节点，右指针移动过程中略过的中间节点都是比当前节点大的。如果当前节点比右指针大，那说明不在同一部分，左指针应该移动到mid的右边，移动所经过的点的值都比当前右指针大，而且mid也比右指针大，所以应该移动到mid右边。
这时候如果左右指针指向同一位置，则说明找到了。
在这里插入图片描述

class Solution {
    public int findMin(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        while(left<right){
            int mid = left + ((right - left) >> 1);
            if(nums[mid] < nums[right]){//说明nums[mid]可能是最小值
                right = mid;
            }else {
                left = mid + 1;//此时mid肯定不是最小值，所以left = mid + 1，因为nums[mid]>nums[right] 注意数组nums中无重复数值
            }
        }
        return nums[left];
    }
}
【Python LeetCode 专题】热题 100，重在思路
一杯水果茶！足矣~
07-17 50
用左右指针。
前端面试题汇总-数据结构（链表）
构建数字世界的感官之桥 | 分享前端工程化、动效魔法与性能之舞！
06-05 1162
在计算机里，不保存在连续存储空间中，而每一个元素里都保存了到下一个元素的地址的数据结构，我们称之为链表（Linked List）。链表上的每一个元素又可以称它为节点（Node），而链表中第一个元素，称它为头节点（Head Node），最后一个元素称它为尾节点（Tail Node）。链表的结构定义中，包含了两个信息，一个是数据信息，用来存储数据的，也叫做数据域；另外一个是地址信息，用来存储下一个节点地址的，也叫做指针域。
面试经典150题 -- 二分查找 (总结)
ros275229的博客
03-06 516
面试经典150题 -- 二分查找 (总结)
二分查找（面试必备）
weixin_34010566的博客
03-15 175
原文：https://subetter.com/algorith...   在计算机科学中，二分搜索（binary search），也称折半搜索（half-interval search）、对数搜索（logarithmic search），是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找...
二分查找面试题
m0_60565784的博客
04-30 889
前言 本文主要叙述一下什么叫二分查找，以及二分查找使用的场景 文章目录二分查找介绍代码展示面试题考法1.在一个有序数组中，找>=某个数最左侧的位置或者在一个有序数组中，找<=某个数最右侧的位置2.存在局部最小值问题 二分查找介绍 二分查找最最常见的就是在有序数组中查找某一个数的位置，具体操作就是用每次用中间元素和所需的数比较，如果在左边就取左部分，右边就取右部分！然后再去部分中间元素比较，直到找到为止！ 代码展示 具体代码： int Binary_search(int arr[], int
骇人听闻的二分查找（某公司校园招聘笔试试题）（据说只有10%的程序员可以写出没有bug的二分查找）
认知 行动 坚持
10-24 1万+
二分查找思路很简单，但要把程序写对，却很难，有兴趣的话，可以在网上查一下相关资料，下面给出两种常见的错误：(至于具体错误原因，可以分析程序的执行) 错误程序1： #include <iostream> using namespace std; int binarySearch(int a[], int n, int key) { int low = 0; ...
面试题目-堆排、快排、二分查找
visionarywind的专栏
01-09 970
排序面试题目 近期在忙着找工作，由于专业跨度的原因，稍微有些焦头烂额，在方向上有些失衡。有种很奇怪的感觉，我不知道换联网公司到底需要什么样的人才，(/ □ \)，好了，吐槽结束了，该继续得还得继续，工作还得继续努力找，希望自己好运吧。 上周面试了一家比较不错的互联网公司，这可能是自己离互联网公司最近的一次了，之前去面过一次爱奇艺，但是，由于对linux下的网络异步通讯这一块不熟，给很快请出来了。
两个月搞定面试算法【小白leetcode刷题训练】【python专场】
AI414010的博客
10-22 3377
前言 刷题顺序来自极客时间，共分为8个专题，每周1个，两个月认真刷完基本大厂面试OK（我说的是认真刷！只抄题解不算）。截止到博主结束秋招时只刷到第5个专题，也基本够用了。也就是说认真刷题的话一个月就可以有offer入手了。 当然现在BAT的笔试做起来还是觉得费力，笔试是真的难啊！ 博主是python选手，题解都是python写的。有问题欢迎交流，共同进步。 文章内附leetcode链接，直接点链接去做就行。同类型的尽量整理到一起了，也方便自己今后复习。 推荐五遍刷题法 1、读题+思考，10分钟内没思路，直接
6.面试算法-链表之高频面试题(一)
最新发布
weixin_36401695的博客
08-11 1055
这是一道经典的链表问题先看一下题目。输入两个链表，找出它们的第一个公共节点。例如下面的两个链表：两个链表的头结点都是已知的，相交之后成为一个单链表，但是相交的位置未知，并且相交之前的结点数也是未知的，请设计算法找到两个链表的合并点。这种问题该怎么入手呢？如果一时想不到该怎么办呢？其实这时候我们可以将常用数据结构和常用算法都想一遍，看看哪些能解决问题。常用的数据结构有数组、链表、队、栈、Hash 、集合、树、堆。常用的算法思想有查找、排序、双指针、递归、迭代、分治、贪心、回溯和动态规划等等。
【搞定算法】常见算法题分类总览
热门推荐
Java学习
07-26 2万+
博主秋招提前批已拿百度、字节跳动、拼多多、顺丰等公司的offer，可加微信：pcwl_Java 一起交流秋招面试经验，可获得博主的秋招简历和复习笔记。 完善中...... 由于本人平时刷题比较零散，有时候找起来不是很方便，所以统一将题目记录于此。主要的题目来源自：剑指 Offer、LeetCode、左神算法、面试、笔试、面经等等。下面按照分类记录： 说明（个人见解）： 一、标注说明 ...
高频面试题之：二分查找（含递归与非递归）
YiGeiGiaoGiao的博客
11-04 278
二分查找
LeetCode-二分查找面试题目总结
Feniox的被虐之路
01-03 776
二分查找的一个面试题
【简单面试题】二分查找算法
天涯何处无芳草，相逢何必曾相识。
01-09 359
有一个有序表为1，5，8，11，19，22，31，35，40，45，48，49，50。index+1`,因为此时index所对应的值是小于所求值num，所以可以直接排除index.,因为此时index所对应的值是大于所求值num，所以可以直接排除index.在拥有512个元素的数组中二分查找一个数，需要比较的次数最多不超过多少次。​ 如果是小鼠，则舍弃小数部分，整数再加1，为最终结果。在一组排好序的数组中，找到所求值的索引。2^n = 512 ，求解n的值即可。，以及左右边界的中间值。
Java面试题：二分查找、冒泡排序
cndn20120225的博客
05-20 626
            //二分查找     private static int binarySearch(int[] arr, int key) { int min = 0; int max = arr.length - 1; int mid = (max + min)/2; while(min &lt;= max) { if(arr[mid] &lt; key) { min...
用一道「二分查找」面试最常考题来给你拜年了！
码农田小齐
01-26 1413
用一道「二分查找」面试最常考题来给你拜年了！ 今天第一题选了我最喜欢的也是折磨了我很久的但并不算难的题目，最终是因为在 GS 电面中被问到了，我才痛下决心把这类题目一网打尽。 先来看最基本版的题目：Leetcode 153题 题干是给了一个【本来排好序了的 且为升序】的数组，然后又在某个不知道的位置旋转了一下，所谓旋转，就是把前面那堆数移到后面来了，求新数组的最小值。比如： 原 array：[0...
极客时间算法课笔记整理12——理论讲解+面试题实战：二分查找
weixin_44436378的博客
12-22 484
这里写目录标题二分查找面试题[69. Sqrt(x)](https://leetcode.com/problems/sqrtx/) 二分查找 适合的规则： sorted（单调递增或者递减） bounded（存在上下界） Accessible by index(能够通过索引访问)：链表不适合，数组适合、 二分查找的代码： 面试题 69. Sqrt(x) 我的代码： 错误：测试案例中的2147395599无法通过，因为是int类型的最大整数值，tmp计算会超过int的取值范围 class Solutio
C++实现二分查找
yangchuang93的博客
09-01 2万+
#include&lt;iostream&gt; using namespace std; int binarySearch(int *arr , int low , int high , int target)//递归实现 { int middle = (low + high)/2; if(low &gt; high) return -1; if(arr[middle] == tar...
【leetcode刷题2】二分查找及其变种
qq_44319285的博客
02-01 324
leetcode 34. 在排序数组中查找元素的第一个和最后一个位置。【二分变种1】 查找右边界 返回右边第一个不是target的值。leetcode 704.二分查找。
准备面试需要知道的经典算法--二分查找
局外人
12-22 628
二分查找 二分查找也称折半查找，是一种在有序数组中查找某一特定元素的搜索算法。从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜 素过程结束； 如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组 为空，则代 表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。折半搜索每次把搜索区域减少一半，时间复杂度
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值