LeetCode算法学习之--二分查找--搜索旋转排序数组2

大家好今天给大家分享下一道 LeetCode 中等难度 的题目[搜索旋转排序数组 II](leetcode-cn.com/problems/co…)

这里主要是分享思路和注释，供大家更好的理解题目解法，代码部分是参考LeetCode 转写成javascript 代码，

题目

已知存在一个按非降序排列的整数数组 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,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

示例 1：

输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true
示例 2：

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

分析

1.有重复值, 则说明在存在nums[l]===nums[mid]的情况

2.数组部分升序另一部分无序，先判断target是否在有序数组中 然后缩小范围

3.寻找target，当nums[mid]===target 则return true

解法

*二分查找+去重法

*/

解法一：二分查找+去重法*

思路
1.先去除重复的干扰项
2.再缩小空间


var search = function (nums, target) {
  let l = 0;
  let r = nums.length - 1;

  while (l <= r) {
    const mid = Math.floor(l + (r - l) / 2);

    // 先判断mid 是否是target 为下面的查找做好准备
    if (nums[mid] === target) {
      return true;
    }

    /* 因为要判断nums[l]到nums[mid]是否是有序数组，所以先去重，为下面的查找做好准备
     同时因为只是判断是否存在，所以可以忽略索引，*/
    //  注意这里一定要加l<mid 不然l可能会大于mid，例如[1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1]
    while (l < mid && nums[l] === nums[mid]) l++;

    // 左边有序， 这里必须要加=， 因为存在一种情况:去重复后l===mid,所以这时候target一定在右边
    if (nums[l] <= nums[mid]) {
      // 如果target 在有序数列中，
      if (nums[l] <= target && target < nums[mid]) {
        // 这里必须是r=mid 不然会错过答案
        r = mid - 1;
      } else {
        l = mid + 1;
      }
    } else {
      // 右边是有序数列

      // 同上如果target 在有序数列中，
      if (nums[mid] < target && target <= nums[r]) {
        // 这里必须是r=mid 不然会错过答案
        l = mid + 1;
      } else {
        r = mid - 1;
      }
    }
  }

  // 如果没有找到 则返回false
  return false;
};

/* 复杂度
时间 O(logn) 
空间 O(1)
*/

解法二: 二分查找 + nums[l]===nums[mid]

思路
1.先判断有序数组
2.再判断无序数组
3.再缩小范围
4.单独列出nums[l]===nums[mid]的情况，有2种情况
  1.找到了目标值
  2.有重复值，所以l++
*/

var search = function (nums, target) {
  let l = 0;
  let r = nums.length - 1;

  while (l <= r) {
    const mid = Math.floor(l + (r - l) / 2);

    // 先判断左边是不是有序
    if (nums[l] < nums[mid]) {
      if (nums[l] <= target && target <= nums[mid]) {
        r = mid;
      } else {
        l = mid + 1;
      }
    // 先判断是不是右边有序
    } else if (nums[mid] < nums[r]) {
      if (nums[mid] < target && target <= nums[r]) {
        l = mid + 1;
      } else {
        r = mid;
      }
    // 如果相等 nums[l]===nums[r]
    } else {
      // 找到了目标
      if (nums[l] === target) {
        return true;
      } else {
        // 去重
        l++;
      }
    }
  }

  return false;
};

/* 复杂度
时间 O(logn)
空间 O(1)
*/

总结

这道题 ，考察的还是大家对二分查找，和旋转数组的理解，里面多了重复的元素，所以考虑的情况就更多了，需要添加更多的限制条件，才能进行二分查找，大家多多练习多多理解，就能掌握要领。

大家可以看看我分享的一个专栏（前端搞算法）里面有更多关于算法的题目的分享，希望能够帮到大家，我会尽量保持每天晚上更新，如果喜欢的麻烦帮我点个赞，十分感谢

文章内容目的在于学习讨论与分享学习算法过程中的心得体会，文中部分素材来源网络，如有侵权，请联系删除，邮箱 182450609@qq.com