❤️ 互联网大厂面试高频算法题汇总 ❤️ —— ❤️ 二分专场 (一) ❤️

最新推荐文章于 2024-05-01 16:54:01 发布
最新推荐文章于 2024-05-01 16:54:01 发布
阅读量2.8w 收藏 63
点赞数 61
分类专栏： 面试高频算法题汇总 文章标签： 算法 面试 力扣 二分查找
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45629285/article/details/119899948
版权

文章目录

1、前言

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法，可以在数据规模的对数时间复杂度内完成查找。二分查找可以应用于数组，是因为数组具有有随机访问的特点，并且数组是有序的。二分查找体现的数学思想是「减而治之」，可以通过当前看到的中间元素的特点推测它两侧元素的性质，以达到缩减问题规模的效果。

二分查找也是面试中经常考到的问题，虽然它的思想很简单，但写好二分查找算法并不是一件容易的事情。因此我汇总了近期互联网大厂面试的高频二分题目，数据来源于CodeTop ，题解来源于我的LeetCode高频面试题专栏，7道高频二分题详解帮助面试者更有针对性地准备面试中的二分算法题。
在这里插入图片描述

2、题目汇总

题目难度最近考察时间频率掌握程度
LeetCode 33. 搜索旋转排序数组中等2021-08-1965⭐⭐⭐
LeetCode 704. 二分查找容易2021-08-2047⭐⭐⭐
LeetCode 69. x 的平方根容易2021-08-2337⭐⭐⭐
LeetCode 4. 寻找两个正序数组的中位数困难2021-08-2127⭐⭐⭐
LeetCode 153. 寻找旋转排序数组中的最小值中等2021-08-1422⭐⭐⭐
LeetCode 162. 寻找峰值中等2021-08-1720⭐⭐⭐
LeetCode 34. 在排序数组中查找元素的第一个和最后一个位置中等2021-08-1218⭐⭐⭐

3、二分模板

版本1

当我们将区间[l, r]划分成[l, mid]和[mid + 1, r]时，其更新操作是r = mid或者l = mid + 1，计算mid时不需要加1。

C++/java代码模板：

int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = (l + r)/2;
        if (check(mid)) r = mid;
        else l = mid + 1;
    }
    return l;
}

版本2

当我们将区间[l, r]划分成[l, mid - 1]和[mid, r]时，其更新操作是r = mid - 1或者l = mid，此时为了防止死循环，计算mid时需要加1。

C++/java 代码模板：

int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = ( l + r + 1 ) /2;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}

代码模板链接： https://www.acwing.com/blog/content/31/

4、二分流程

  • 1、确定二分的区间[l,r]，一般都是l = 0, r = nums.size() - 1。
  • 2、编写二分的代码模板。
  • 3、确定判断条件check，可以通过画图来判断当满足check时，区间该如何更新。

5、二分高频题详解

5.1、LeetCode 33. 搜索旋转排序数组

题目：

整数数组 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。

示例 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
  • -10^4 <= nums[i] <= 10^4
  • nums 中的每个值都 独一无二
  • 题目数据保证 nums在预先未知的某个下标上进行了旋转
  • -10^4 <= target <= 10^4

思路

(二分) O ( l o g n ) O(logn) O(logn)

1、先找到旋转点，在旋转点左边的点都比nums[0]大，右边的点都比nums[0]小，因此可以用二分找到该点

  • 当nums[mid] >= nums[0]时，往右边区域找，l = mid。

  • 当nums[mid] < nums[0]时，往左边区域找，r = mid - 1。

2、找到旋转点l后，可以知道[0,l - 1],[l,n - 1]是两个有序数组，判断出target的值在哪个有序数组中，确定好二分的区间[l,r]

3、在[l,r]区间中，由于该区域也具有单调性，通过二分找到该值的位置

  • 当nums[mid] >= target时，往左边区域找，r = mid。

  • 当nums[mid] < target时， 往右边区域找, l = mid + 1。

4、若最后找到的元素nums[r] != target，则表示不存在该数，返回-1，否则返回该数值

c++代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
       if(nums.empty()) return -1; 
       //先二分转折点 二分>=nums[0]的最右边
       int l = 0, r = nums.size() - 1;
       while( l < r)
       {
           int mid = (l + r + 1)/2;
           if(nums[mid] >= nums[0]) l = mid;
           else r = mid - 1;
       }
       if(target >= nums[0]) l = 0;  //target在左半边区域
       else l = r + 1, r = nums.size() - 1; //target在右半边区域
       while( l < r)
       {
           int mid = ( l + r)/2;
           if( nums[mid] >= target) r = mid;
           else l = mid + 1;
       }
       if(nums[r] == target) return r;//二分的while循环的结束条件是l>=r，所以在循环结束时l有可能会大于r，此时就可能导致越界，基本上二分问题优先取r都不会翻车。
       return -1;
    }
};

java代码

class Solution {
    public int search(int[] nums, int target) {
        if(nums.length == 0) return -1; 
       //先二分转折点 二分>=nums[0]的最右边
       int l = 0, r = nums.length - 1;
       while( l < r)
       {
           int mid = (l + r + 1)/2;
           if(nums[mid] >= nums[0]) l = mid;
           else r = mid - 1;
       }
       if(target >= nums[0]) l = 0;  //target在左半边区域
       else
       {
           l = r + 1;
           r = nums.length - 1; //target在右半边区域
       } 
       while( l < r)
       {
           int mid = ( l + r)/2;
           if( nums[mid] >= target) r = mid;
           else l = mid + 1;
       }
       if(nums[r] == target) return r;//二分的while循环的结束条件是l>=r，所以在循环结束时l有可能会大于r，此时就可能导致越界，基本上二分问题优先取r都不会翻车。
       return -1;
    }
}

5.2、LeetCode 704. 二分查找

题目

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

  • 你可以假设 nums中的所有元素是不重复的。
  • n 将在 [1, 10000]之间。
  • nums 的每个元素都将在 [-9999, 9999]之间。

思路

(二分) O ( l o g n ) O(logn) O(logn)

1、在[l,r]区间中，nums[i]数组具有单调性，因此可以通过二分>=target的最左边界找到该值的位置

  • 当nums[mid] >= target时，往左边区域找， r = mid
  • 当nums[mid] < target时，往右边区域找，l = mid + 1

2、若最后找到的元素nums[r] != target，则表示不存在该数，返回-1，否则返回数值r

c++代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
      if(!nums.size()) return -1;
      int  l = 0, r =nums.size() - 1;
      while(l < r)   //二分>=x的最左边界
      {
          int mid = (l + r) / 2;
          if(nums[mid] >= target) r = mid;
          else l = mid + 1;
      }
      if(nums[r] == target) return r;
      else return -1;
    }
};

java代码

class Solution {
    public int search(int[] nums, int target) {
     if(nums.length == 0) return -1;
      int  l = 0, r =nums.length- 1;
      while(l < r) //二分>=x的最左边界
      {
          int mid = (l + r) / 2;
          if(nums[mid] >= target) r = mid;
          else l = mid + 1;
      }
      if(nums[r] == target) return r;
      else return -1;
    }
}

5.3、LeetCode 69. x 的平方根

题目

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

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

示例 1:

输入: 4
输出: 2

示例2：

输入: 8
输出: 2

说明:

  • 8的平方根是 2.82842…,
  • 由于返回类型是整数，小数部分将被舍去。

思路

(二分) O ( l o g x ) O(logx) O(logx)

我们二分出最大的 y 2 < = x y^2 <= x y2<=x ,那么y就是答案

过程

  • 1、我们从l = 0，r = x开始，先让mid = (l + r + 1)/2
  • 2、如果mid * mid <= x ，则往右边查找，即l = mid，否则往左边查找，即r = mid - 1。

图示过程

时间复杂度 O ( l o g x ) O(logx) O(logx)

注意点

  • 1、r最大可以取INT_MAX再加上1就会超出int范围，因此我们将其写成l + r +1ll强转为long long类型，再/2就不会出现越界情况了。
  • 2、mid * mid可能会超出int的范围，因此判断条件写成 if( mid <= x/mid )。

c++代码

class Solution {
public:
    int mySqrt(int x) {
        int l = 0 , r = x;
        while(l < r)
        {
            int  mid = (l + r + 1ll)/2;
            if(mid <= x/mid) l = mid;
            else r = mid - 1;
        }
        return r;
    }
};

java代码

class Solution {
    public int mySqrt(int x) {
        int l = 0, r = x;
        while(l < r)
        {
            int mid = (int)(l + r + 1L >> 1);
            if(mid <= x / mid) l = mid;
            else r = mid - 1;
        }
        return l;
    }
}

5.4、LeetCode 4. 寻找两个正序数组的中位数

题目

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

示例 3：

输入：nums1 = [0,0], nums2 = [0,0]
输出：0.00000

示例 4：

输入：nums1 = [], nums2 = [1]
输出：1.00000

示例 5：

输入：nums1 = [2], nums2 = []
输出：2.00000

提示：

  • nums1.length == m
  • nums2.length == n
  • 0 <= m <= 1000
  • 0 <= n <= 1000
  • 1 <= m + n <= 2000
  • -106 <= nums1[i], nums2[i] <= 106

进阶： 你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？

思路

(递归，二分) O ( l o g ( n + m ) ) O(log(n+m)) O(log(n+m))

找出两个正序数组的中位数等价于找出两个正序数组中的第k小数。如果两个数组的大小分别为n和m ，那么第 k = (n + m)/2 小数就是我们要求的中位数。

如何寻找第k小的元素？

过程如下：

1、考虑一般情况，我们在 nums1和nums2数组中各取前k/2个元素

or_FFFFFF,t_70,g_se,x_16#pic_center)

我们默认nums1数组比nums2数组的有效长度小 。nums1数组的有效长度从i开始，nums2数组的有效长度从j开始，其中[i,si - 1]是nums1数组的前k / 2个元素，[j, sj - 1]是nums2数组的前k / 2个元素。

2、接下来我们去比较nums1[si - 1]和nums2[sj - 1]的大小。

  • 如果nums1[si - 1] > nums2[sj - 1] ，则说明 nums1 中取的元素过多，nums2 中取的元素过少。因此nums2 中的前 k/2个元素一定都小于等于第 k 小数，即nums2[j,sj-1]中元素。我们可以舍去这部分元素，在剩下的区间内去找第k - k / 2小的元素，也就是说第k小一定在[i,n]与[sj,m]中。
  • 如果nums1[si - 1] <= nums2[sj - 1]，同理可说明nums2中的前 k/2个元素一定都小于等于第 k 小数，即nums1[i,si-1]中元素。我们可以舍去这部分元素，在剩下的区间内去找第k - k / 2小的元素，也就是说第k小一定在[si,n]与[j,m]中。

3、递归过程2，每次可将问题的规模减少一半，最后剩下的一个数就是我们要找的第k小数。

递归边界：

  • 当nums1数组为空时，我们直接返回nums2数组的第k小数。
  • 当k == 1时，且两个数组均不为空，我们返回两个数组首元素的最小值，即min(nums1[i], nums2[j])。

奇偶分析：

  • 当两个数组元素个数的总和total为偶数时，找到第total / 2小left和第total / 2 + 1小right，结果是(left + right / 2.0)。

  • 当total为奇数时，找到第total / 2 + 1小，即为结果。

时间复杂度分析： k = ( m + n ) / 2 k=(m+n)/2 k=(m+n)/2，且每次递归 k k k 的规模都减少一半，因此时间复杂度是 O ( l o g ( m + n ) ) O(log(m+n)) O(log(m+n)).

这道题是二分类型的题目，但使用递归解法会更通俗易懂，每次递归 k k k 的规模都减少一半，也是二分的思想体现。

c++代码

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int tot = nums1.size() + nums2.size();
        if (tot % 2 == 0) {
            int left = find(nums1, 0, nums2, 0, tot / 2);
            int right = find(nums1, 0, nums2, 0, tot / 2 + 1);
            return (left + right) / 2.0;
        } else {
            return find(nums1, 0, nums2, 0, tot / 2 + 1);
        }
    }

    int find(vector<int>& nums1, int i, vector<int>& nums2, int j, int k) {
        if (nums1.size() - i > nums2.size() - j) return find(nums2, j, nums1, i, k);
        if (k == 1) {
            if (nums1.size() == i) return nums2[j];
            else return min(nums1[i], nums2[j]);
        }
        if (nums1.size() == i) return nums2[j + k - 1];
        int si = min((int)nums1.size(), i + k / 2), sj = j + k - k / 2;
        if (nums1[si - 1] > nums2[sj - 1])
            return find(nums1, i, nums2, sj, k - (sj - j));
        else
            return find(nums1, si, nums2, j, k - (si - i));
    }
};

java代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int total = nums1.length + nums2.length;
        if(total % 2 == 0)
        {
            int left = f(nums1,0,nums2,0,total / 2);
            int right = f(nums1,0,nums2,0,total / 2 + 1);
            return (left + right) / 2.0;
        }
        else return f(nums1,0,nums2,0,total / 2 + 1);
    }
    static int f(int[] nums1,int i,int[] nums2,int j,int k)
    {
        //默认第一个是小的
        if(nums1.length - i > nums2.length - j) return f(nums2,j,nums1,i,k);
        //当第一个数组已经用完
        if(nums1.length == i) return nums2[j + k - 1];
        //当取第1个元素
        if(k == 1) return Math.min(nums1[i],nums2[j]);

        int si = Math.min(nums1.length,i + k / 2),sj = j + k - k / 2;
        if(nums1[si - 1] > nums2[sj - 1])
        {
            return f(nums1,i,nums2,sj,k - (sj - j));
        }
        else
        {
            return f(nums1,si,nums2,j,k - (si - i));
        }
    }
}

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

题目

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

  • 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
  • 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。

示例 1：

 输入：nums = [3,4,5,1,2]
 输出：1
 解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

 输入：nums = [4,5,6,7,0,1,2]
 输出：0
 解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。

示例 3：

 输入：nums = [11,13,15,17]
 输出：11
 解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。

提示：

  • n == nums.length
  • 1 <= n <= 5000
  • -5000 <= nums[i] <= 5000
  • nums 中的所有整数 互不相同
  • nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

思路

(二分) O ( l o g n ) O(logn) O(logn)

为了便于分析，我们先将数组中的数画在二维坐标系中，横坐标表示数组下标，纵坐标表示数组数值，如下所示：

我们发现：竖直虚线左边的数满足 ，而竖直虚线右边的数满足，分界点就是整个数组的最小值。数组具有二分性，所以我们可以二分出最小值的位置。

过程如下：

  • 1、在[l,r]区间中，l = 0, r = nums.size() - 1，我们去二分<num[0]的最左边界。
  • 2、当nums[mid] < nums[0]时，往左边区域找，r = mid。。
  • 3、当nums[mid] >= nums[0]时，往右边区域找，l = mid + 1。
  • 4、当只剩下一个数时，就是最小值的位置。

细节：

  • 当数组完全单调时，第一个数nums[0]最小，我们直接返回即可。

时间复杂度分析： 二分查找，所以时间复杂度是 O ( l o g n ) O(logn) O(logn) 。

c++代码

 class Solution {
 public:
     int findMin(vector<int>& nums) {
         int l = 0, r = nums.size() - 1;
         if(nums[r] > nums[l]) return nums[0];  //升序数组，数组完全单调，第一个数最小
         while(l < r)
         {
             int mid = (l + r)/2;
             if(nums[mid] < nums[0])  r = mid;
             else l = mid + 1;
         }
         return nums[r];
     }
 };

java代码

 class Solution {
     public int findMin(int[] nums) {
         int l = 0, r = nums.length - 1;
         if(nums[r] > nums[l]) return nums[0];  //升序数组，数组完全单调，第一个数最小
         while(l < r)
         {
             int mid = (l + r)/2;
             if(nums[mid] < nums[0])  r = mid;
             else l = mid + 1;
         }
         return nums[r];
     }
 }

5.6、LeetCode 162. 寻找峰值

题目

峰值元素是指其值大于左右相邻值的元素。

给你一个输入数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞ 。

示例 1：

输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。

示例 2：

输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5 
解释：你的函数可以返回索引 1，其峰值元素为 2；
     或者返回索引 5， 其峰值元素为 6。

提示：

  • 1 <= nums.length <= 1000
  • -231 <= nums[i] <= 231 - 1
  • 对于所有有效的i都有 nums[i] != nums[i + 1]

思路

(二分) O ( l o g n ) O(logn) O(logn)

数组的两端nums[-1] = nums[n] = -∞ 都是负无穷，因此数组无论是单调递增还是单调递减，又或者是成起伏状，数组中必定包含一个峰值。如下图所示：

因为数组中的峰值不止一个，我们找到任意一个即可。题目还告诉我们对于所有有效的i都有 nums[i] != nums[i + 1]，即数组中的任意两个相邻数都不相等。

我们使用二分来做，每次找出区间的中点mid，比较nums[mid]与nums[mid + 1]的大小关系来推断哪个区间内一定存在峰值，然后取一定存在峰值的区间。这样不断缩小区间范围，区间所剩下的最后一个数就是答案。

过程如下：

  • 1、二分的边界，l = 0, r = nums.size() - 1。
  • 2、如果nums[mid] > nums[mid + 1]，那么在[l, mid]这个区间内一定存在一个峰值。因为[l,mid]这一段如果是单调递减的话，那么nums[l]就是峰值，否则第一个出现上升的点就是峰值。
  • 3、如果nums[mid] < nums[mid + 1]，那么在[mid+1, r]这个区间内一定存在一个峰值。因为[mid+1,r]这一段如果是单调递增的话，那么nums[r]就是峰值，否则第一个出现下降的点就是峰值。

时间复杂度分析： 二分查找，所以时间复杂度是 O ( l o g n ) O(logn) O(logn)。

c++代码

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int l = 0, r = nums.size() - 1;
        while( l < r)
        {
            int mid = ( l + r )/2;
            if(nums[mid] > nums[mid + 1]) r = mid;
            else l = mid + 1;
        }
        return r;
    }
};

java代码

class Solution {
    public int findPeakElement(int[] nums) {
        int l = 0, r = nums.length - 1;
        while( l < r)
        {
            int mid = ( l + r )/2;
            if(nums[mid] > nums[mid + 1]) r = mid;
            else l = mid + 1;
        }
        return r;
    }
}

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

题目

给定一个按照升序排列的整数数组 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
  • num 是一个非递减数组
  • -109 <= target <= 109

思路

(二分) O ( l o g n ) O(logn) O(logn)

在一个范围内，查找一个数字，要求找到这个元素的开始位置和结束位置，这个范围内的数字都是单调递增的，即具有单调性质，因此可以使用二分来做。

两次二分，第一次二分查找第一个`>=target`的位置，第二次二分查找最后一个`<=target`的位置。查找成功则返回两个位置下标，否则返回`[-1,-1]`。

具体二分过程如下：

第一次

  • 1、二分的范围，l = 0， r = nums.size() - 1，我们去二分查找>=target的最左边界。

  • 2、当nums[mid] >= target时，往左半区域找，r = mid。

  • 3、当nums[mid] < target时， 往右半区域找，l = mid + 1。

  • 4、如果nums[r] != target，说明数组中不存在目标值 target，返回 [-1, -1]。否则我们就找到了第一个>=target的位置L。

第二次

  • 1、二分的范围，l = 0， r = nums.size() - 1，我们去二分查找<=target的最右边界。

  • 2、当nums[mid] <= target时，往右半区域找，l = mid。

  • 3、当nums[mid] > target时， 往左半区域找，r = mid - 1。

  • 4、找到了最后一个<=target的位置R，返回区间[L,R]即可。

时间复杂度分析： 两次二分查找的时间复杂度为 O ( l o g n ) O(logn) O(logn)。

c++代码

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(nums.empty()) return {-1,-1};
    
        int l = 0, r = nums.size() - 1; //二分范围
        while( l < r)			//查找元素的开始位置
        {
            int mid = (l + r )/2;
            if(nums[mid] >= target) r = mid;
            else l = mid + 1;
        }
        if( nums[r] != target) return {-1,-1};
        int L = r;
        l = 0, r = nums.size() - 1;
        while( l < r)          //查找元素的结束位置
        {
            int mid = (l + r + 1)/2;
            if(nums[mid] <= target ) l = mid;
            else r = mid - 1;
        }
        return {L,r};
    }
};

java代码

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums.length == 0) return new int[]{-1,-1};
    
        int l = 0, r = nums.length - 1; //二分范围
        while( l < r)			//查找元素的开始位置
        {
            int mid = (l + r )/2;
            if(nums[mid] >= target) r = mid;
            else l = mid + 1;
        }
        if( nums[r] != target) return new int[]{-1,-1};
        int L = r;
        l = 0; r = nums.length - 1;
        while( l < r)			//查找元素的结束位置
        {
            int mid = (l + r + 1)/2;
            if(nums[mid] <= target ) l = mid;
            else r = mid - 1;
        }
        return new int[]{L,r};
    }
}

笔记已汇总成PDF，私信我免费领取。
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

林小鹿@
关注
  • 61
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 83
    评论
专栏目录
左程云老师亲自讲解：当前大厂笔试最高频的十道算法题
wdjnb的博客
12-24 1952
前言 最近不少小伙伴跟我交流刷题肿么刷，我给的建议就是先剑指offer和力扣hot100，在这些题中还有些重要程度和出现频率是非常非常高的，今天给大家分享当今出现频率最高的10道算法题，学到就是赚到。 0X01翻转链表 力扣206和剑指offer24原题，题意为： 给你单链表的头节点head，请你反转链表，并返回反转后的链表。 分析： 翻转链表，本意是不创建新的链表节点然后在原链表上实现翻转，但是这个图有点会误导人的思维，其实更好的理解你可以看下面这幅图： 具体实现上两个思路，..
初级程序员进大厂必刷的100道算法题
Web前端开发工程师
06-30 8785
碎碎念： 读者你好我的名字叫昌龙 【Changlon】 —— 一个非科班程序员、一个致力于前端的开发者、一个热爱生活且又时有忧郁的思考者。 如果我的文章能给你带来一些收获你的点赞收藏将是对我莫大的鼓励！ 我的邮箱:thinker_changlon@163.com 我的Github: https://github.com/Changlon 程序员之进大厂必刷算法题系列 数组 字符串 链表 栈 哈希 二叉树 二分算法 分治算法(快排序) 动态规划 深度优先，广度优先算法 递归，回溯算法 贪心算法 ..
大厂面试算法100题
10-31
收集来自微软,百度,腾讯等一线互联网企业关于算法的100道面试题,希望对大家有帮助.更多面试相关资料也可以找我.我设置的是0积分,但是老被系统改,如果需要积分才能下载可以私信我.....
查找不含有重复字符的最长子串的长度
weixin_44783458的博客
12-07 467
给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。 public static int lengthOfLongestSubstring(String s) { int rs = 0; int[] last = new int[128]; for (int i = 0; i < 128; i++) { last[i] = -1; } int start = 0; for
2024年刷这600多道算法题，轻松进大厂_进大厂刷多少算法题才有底气
最新发布
2301_82244125的博客
05-01 20
如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。
大厂面试 高频 数据结构 & 算法题 【top 200】 大汇总
weixin_41888257的博客
07-11 1288
一、二叉树 二、链表 三、DFS、BFS 四、动态规划
2020互联网一线大厂面试真题附含答案.zip
09-26
"2020互联网一线大厂面试真题附含答案.zip"这个压缩包文件包含了多个准备大厂面试的重要资源，如面试真题目录、高频面试题以及多份大厂面试的详细题目。这些资料对于求职者来说，是提升面试技能、了解企业需求的关键...
2019年互联网大厂高频重点面试题第二季（思维导图+视频）
08-22
尚硅谷2019年互联网大厂高频重点面试题第二季， 内容包括JUC多线程并发、JVM和GC等目前大厂笔试中会考、面试中会问、工作中会用的高频难点知识。从多线程并发入手，分层递进讲解，逐步让大家掌握volatile、原子类和...
互联网大厂高频重点面试题.txt
03-03
java互联网大厂高频重点面试题
【原价2300！！】尚硅谷_互联网大厂高频重点面试题视频详细讲解
10-13
JUC多线程并发、JVM和GC等目前大厂笔试中会考、面试中会问、工作中会用的高频难点知识。上半场，从多线程并发入手，分层递进讲解，逐步让大家掌握volatile、原子类和原子引用、CAS、ABA、Java锁机制、阻塞队列、...
互联网大厂面试真题附含答案高频面试题
08-12
面试；真题；题海
大厂算法面试题库中高频出现的30道典型题
04-09
大厂算法面试题库中,高频出现的30道典型题
BAT大厂面试的100道考题【算法、源码、架构、中间件、设计模式、网络、项目】，过60分的不到10%
热门推荐
bugstack虫洞栈
09-19 34万+
其实这些考题只是相当于在你的技术栈地图中，拎出100个检查站点，进行片段化的提问，来检查你对知识网的覆盖程度。而学习的最终目标远不是来背这些题，那样是没有多大的意义的，否则你在面对面试官时换个方向再问，可能你还是没法回答。所以更有意义的事是慢下来，不贪多，一步一个脚印的用自己的思考和实践验证学会这些内容。
2021年经典大厂面试题——算法与数据结构版（含答案）
e891377的专栏
08-12 1667
经典大厂面试题 请问，Object作为HashMap的key的话，对Object有什么要求吗？ 请问 hashset 存的数是有序的吗？ 输入一个二叉树和一个整数，打印出二叉树中节点值的和等于输入整数所有的路径 二叉树的搜索区间 现在有一个单向链表，谈一谈，如何判断链表中是否出现了环 随机链表的复制 找出数组中和为S的一对组合，找出一组就行 求一个数组中连续子向量的最大和 谈一谈，如何得到一个数据流中的中位数？ 你知道哪些排序算法，这些算法的时间复杂度分别是多少，解释一下快排？ 请你解释一下，内存中的栈
2024年面试大厂必背算法题
key_honghao的博客
09-19 241
掌握以下即可面试一、数组与字符串操作1、找出数组中的最大值、最小值、第 K 大的元素。a. 找出数组中的最大值b. 找出数组中的最小值c. 找出数组中的第 K 大的元素2、求数组中的两个数之和为特定值的下标。3、判断一个字符串是否是回文串。4、旋转数组：将数组向右旋转 k 步。二、链表问题1、反转链表。2、检测链表中是否存在环。3、合并两个有序链表。4、删除链表中倒数第 N 个节点。三、树与图问题1、二叉树的遍历（前序、中序、后序、层序）。2、判断二叉树是否对称。3、在二叉树中查找路径和等于给定值的路径。
中大厂前端面试常考算法
qq_43510829的博客
05-08 1504
基本都是力扣上的简单题，有精力的话可以寻求更好的方法。以下题目都是笔者面大厂的亲身经历 快速排序（腾讯） // 最基础的方法，很直观，还有更好的方法 function quickSort (arr) { if (arr.length <= 1) return arr // 递归判断结束 let index = Math.floor(arr.length / 2) // 取中间数索引 let center = arr.splice(index, 1)[0] // 取索引对应元素并将.
给秋招加点料——Hot15道高频算法面试题！
Rikkaの博客
06-25 964
目录1.链表篇反转链表判断链表中是否有环合并有序链表2.动态规划篇跳台阶子数组的最大累加和求路径最长公共子串3.树篇两个节点最近公共祖先实现二叉树先中后序排列二叉树之字形遍历4.二分篇求平方根5.其他岛屿数量最长无重复子串括号生成有重复数字的所有排列 1.链表篇 反转链表 难度：easy 考察次数：189 传送门 题目描述 输入一个链表，反转链表后，输出新链表的表头。 思路:创建三个指针，一个表示前一个结点pre，一个表示当前节点cur，一个表示后一个节点next。循环next=cur->next，c
程序员须知：大厂面试最容易被问到的算法题（附答案）
LintCode的博客
07-02 460
谷歌面试题：最小步数 描述 有一个1∗n的棋盘，分别标号为0,1,2…n−1，棋盘的每个格子都有一种颜色。 现在，在0号位置有一枚棋子，请求出最少移动几步能到达最后一格。 棋子有3种移动的方法，且棋子不能移出到棋盘外： 棋子从位置 i 移动到位置 i+1。 棋子从位置 i 移动到位置 i−1。 如果位置 i 和位置 j 的颜色相同，那么棋子可以直接从位置 i 移动到位置 j。 棋盘的大小为 1∗n，2≤n≤105。 第 i 格子的颜色编号 colorsi，满足 1≤colorsi≤n。 在线评测地址 样
【大厂秋招高频算法】阿里秋招高频算法题汇总（基础篇）
qq_45260619的博客
03-15 1044
这里讲一下阿里秋招中的高频算法题，分为三个部分： 基础篇 、 中级篇 、 进阶篇 目的就是为了应对秋招中的算法题，其实过算法题的诀窍就在于 理解的基础上 + 背会 看到一个题目，首先要了解题目考察的算法是什么，这个算法要理解，至于具体实现的话，就靠背会了（多写、多练），没有什么捷径！ 还有一点要注意的是，在大厂的比试中， 可能考察算法的方式是 ACM 模式 ，这一点和力扣上不同，ACM 模式需要我们自己去引入对应的包，以及自己写算法，力扣是将方法框架给定，只需要在方法内写代码就可以了，这一点要注意！
2023年大厂前端面试高频算法题：合并有序链表
在2023年的前端求职面试中，算法题作为高频考点，对于理解和解决这类问题至关重要。本篇内容主要关注于合并两个有序链表的问题，这是一个经典的编程题目，常用于考察面试者的数据结构和递归/迭代思维。 题⽬描述： ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林小鹿@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值