算法系列--二分查找

最新推荐文章于 2022-01-01 20:36:01 发布
最新推荐文章于 2022-01-01 20:36:01 发布
阅读量189 收藏
点赞数
分类专栏： 算法 javascript 文章标签： 数据结构 二分法 二分查找 有序数组 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bob_baobao/article/details/109647125
版权

二分查找是一种效率较高的查找方法，前提是数据结构必须先排好序，它的平均时间复杂度是O(logn)。碰到排好序的数组，第一时间应该想到用二分法求解。

二分查找的递归与非递归实现

  1. 在有序数组arr中，查找目标值value的元素下标
// 递归
function biSearch(arr, start, end, value) {
  if (start > end) return -1
  let mid = Math.floor((start + end) / 2)
  if (arr[mid] < value) {
    return biSearch(arr, mid + 1, end, value)
  } else if (arr[mid] > value) {
    return biSearch(arr, start, mid - 1, value)
  } else {
    return mid
  }
}

// 非递归
function biSearch(arr, value) {
  let start = 0
  let end = arr.length - 1
  let mid = (start + end) >> 1
  while (start <= end) {
    if (arr[mid] === value) {
      return mid
    }
    if (arr[mid] < value) {
      start = mid + 1
    } else {
      end = mid - 1
    }
    mid = (start + end) >> 1
  }
  return -1
}

二分查找变形问题

  1. 在有序数组中，查找第一个等于给定值的元素的下标
// 遍历
function getFirstOne(arr, value) {
  let start = 0
  let end = arr.length - 1
  let mid = (start + end) >> 1
  while (start <= end) {
    if (arr[mid] > value) {
      end = mid - 1
    } else if (arr[mid] < value) {
      start = mid + 1
    } else {
      if (mid === start || arr[mid - 1] !== value) {
        return mid
      } else {
        end = mid - 1
      }
    }
    mid = (start + end) >> 1
  }
  return -1
}

let arr = [2,2,2,3,3,4,5,6,6,7]
let value = 10
let result = getFirstOne(arr, value)
console.log('result', result)

// 递归
// 递归
function getFirstOne(arr, start, end, value) {
  if (start > end) return -1
  let mid = (start + end) >> 1
  if (arr[mid] > value || (mid !== start && arr[mid-1] === value)) {
    return getFirstOne(arr, start, mid - 1, value)
  } else if (arr[mid] < value) {
    return getFirstOne(arr, mid + 1, end, value)
  } else {
    return mid
  }
}
let arr = [2,2,2,3,3,4,5,6,6,7]
let value = 3
let result = getFirstOne(arr, 0, arr.length - 1, value)
console.log('result', result)
  1. 在有序数组中，查找最后一个等于给定值的元素的下标
// 遍历
function getLastOne(arr, value) {
  let start = 0
  let end = arr.length - 1
  let mid = (start + end) >> 1
  while (start <= end) {
    if (arr[mid] < value) {
      start = mid + 1
    } else if (arr[mid] > value) {
      end = mid - 1
    } else {
      if (mid === end || arr[mid+1] !== value) {
        return mid
      } else {
        start = mid + 1
      }
    }
    mid = (start + end) >> 1
  }
  return -1
}
let arr = [2,2,2,3,3,4,5,6,6,7]
let value = 3
let result = getLastOne(arr, value)
console.log('result', result)

// 递归
function getLastOne(arr, start, end, value) {
  if (start > end) return -1
  let mid = (start + end) >> 1
  if (arr[mid] < value) {
    return getLastOne(arr, mid + 1, end, value)
  } else if (arr[mid] > value) {
    return getLastOne(arr, start, mid - 1, value)
  } else {
    if (mid === end || arr[mid + 1] !== value) {
      return mid
    } else {
      return getLastOne(arr, mid + 1, end, value)
    }
  }
}
let arr = [2,2,2,3,3,4,5,6,6,7]
let value = 3
let result = getLastOne(arr, 0, arr.length - 1, value)
console.log('result', result)
  1. 在有序数组中，查找第一个大于等于给定值的元素的下标
// 遍历
function getFirstMaxOne(arr, value) {
  let start = 0
  let end = arr.length - 1
  let mid = (start + end) >> 1
  while (start <= end) {
    if (arr[mid] < value) {
      start = mid + 1
    } else {
      if (arr[mid - 1] < value || mid === start) {
        return mid
      }
      end = mid - 1
    }
    mid = (start + end) >> 1
  }
  return -1
}
let arr = [2,2,2,3,3,4,5,6,6,7]
let value = 6
let result = getFirstMaxOne(arr, value)
console.log('result', result)

// 递归
function getFirstMaxOne(arr, start, end, value) {
  if (start > end) return -1
  let mid = (start + end) >> 1
  if (arr[mid] < value) {
    return getFirstMaxOne(arr, mid + 1, end, value)
  } else {
    if (arr[mid-1] < value || mid === start) {
      return mid
    }
    return getFirstMaxOne(arr, start, mid - 1, value)
  }
}
let arr = [2,2,2,3,3,4,5,6,6,7]
let value = 2
let result = getFirstMaxOne(arr, 0, arr.length - 1, value)
console.log('result', result)
  1. 在有序数组中，查找最后一个小于等于给定值的元素的下标
// 遍历
function getFirstMaxOne(arr, value) {
  let start = 0
  let end = arr.length - 1
  let mid = (start + end) >> 1
  while (start <= end) {
    if (arr[mid] < value) {
      start = mid + 1
    } else {
      if (arr[mid - 1] < value || mid === start) {
        return mid
      }
      end = mid - 1
    }
    mid = (start + end) >> 1
  }
  return -1
}
let arr = [2,2,2,3,3,4,5,6,6,7]
let value = 6
let result = getFirstMaxOne(arr, value)
console.log('result', result)

// 递归
function getLastMinOne(arr, value) {
  let start = 0
  let end = arr.length - 1
  let mid = (start + end) >> 1
  while (start <= end) {
    if (arr[mid] > value) {
      end = mid - 1
    } else {
      if (arr[mid + 1] > value || mid === end) {
        return mid
      }
      start = mid + 1
    }
    mid = (start + end) >> 1
  }
  return -1
}
let arr = [2,2,2,3,3,4,5,6,6,7]
let value = 2
let result = getLastMinOne(arr, value)
console.log('result', result)

其它经典试题

  1. 在有序的稀疏数组中，查找目标值
function findStr(words, s) {
  let start = 0
  let end = words.length - 1
  let mid = (start + end) >> 1
  while (start <= end) {
    // 遇到特殊字符，退化成线性
    while (words[mid] === '' && mid > start) {
      mid = mid - 1
    }
    if (words[mid] === s) {
      return mid
    }
    if (words[mid] > s) {
      end = mid - 1
    } else {
      start = mid + 1
    }
    mid = (start + end) >> 1
  }
  return -1
}
  1. 在有序的数组中，查找确实的数字
// 缺失数字
function missNum(nums) {
  let start = 0
  let end = nums.length - 1
  while (start <= end) {
    let mid = (start + end) >> 1
    if (nums[mid] <= mid) {
      start = mid + 1
    } else {
      if (nums[mid-1] === mid - 1 || mid === start) {
        return mid
      }
      end = mid - 1
    }
  }
  return nums.length
}
let nums = [1,2,3,4,5,6,7]
let result = missNum(nums)
console.log('result', result)
  1. 在有序的数组中，统计目标值出现的次数
function search(nums, target) {
  let start = 0
  let end = nums.length - 1
  let times = 0
  while (start <= end) {
    let mid = (start + end) >> 1
    let temp = mid
    if (nums[mid] < target) {
      start = mid + 1
    } else if (nums[mid] > target) {
      end = mid - 1
    } else {
      // 左边统计
      while (temp >= start && nums[temp] === target) {
        times++
        temp--
      }
      // 右边统计
      temp = mid + 1
      while(temp <= end && nums[temp] === target) {
        times++
        temp++
      }
      break
    }
  }
  return times
}
let nums = [9, 9, 10, 11, 12, 12, 12, 12]
let result = search(nums, 12)
console.log('result', result)
  1. 查找第K小的元素
    leetcode378
// 查找第K小的元素，二维矩阵 O(nlogn)
function fn2(matrix, k) {
  let n = matrix.length
  if (k < 0 || k > n * n) return null
  let start = matrix[0][0]
  let end = matrix[n-1][n-1]
  while (start < end) {
    let mid = (start + end) >> 1
    let num = getNum(matrix, mid)
    if (num >= k) {
      end = mid
    } else {
      start = mid + 1
    }
  }
  return start
}

// 二维矩阵中，获取小于目标值的数量 O(n)
function getNum(matrix, value) {
  let n = matrix.length
  let i = n - 1
  let j = 0
  let num = 0
  while(i >= 0 && j < n) {
    if (matrix[i][j] <= value) {
      num = num + i + 1
      j++
    } else {
      i--
    }
  }
  return num
}

总结

二分查找问题很常见，碰到关键字有序数组，时间复杂度O（logn），就要想到用二分查找；具体实现可以用遍历或者递归，多练习就能熟能生巧。

Bob丶抱抱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二分查找及时间复杂度
weixin_42137701的博客
08-17 6029
1、搜索 搜索是在一个项目集合中找到一个特定项目的算法过程。搜索通常的答案是真或假，因为该项目是否存在。搜索的几种常见方法：顺序查找、二分法查找、二叉树查找、哈希查找。 2、二分法查找 二分法查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中的元素是按升序排序，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分为前、后两个子表，如果中间位置记录
算法系列：二分查找
闵行小鱼塘
09-09 386
本篇归纳二分查找
简单biSearch使用-记录算法的第一天
qq_48146525的博客
09-01 350
leetcode算法入门第一天，，时隔俩月，终于又双打开了算法基础大门，开始了三分热度° 的奋斗~ ~ ~ ~ 需要test的伙伴这里连接：https://leetcode-cn.com/problems/binary-search/submissions/ 1-二分查找 第一次尝试 先给个测试通过的demo： class Solution { public int search(int[] nums, int target) { int ans = biSearch(nums,0,n
算法：二分查找法
OceanStar的博客
04-28 8561
引入 二分查找是一种非常简单易懂的快速查找算法，生活中到处可见。 例子一 我们现在来做一个猜字游戏。我随机写一个 0 到 99 之间的数字，然后你来猜我写的是什么。猜的过程中，你每猜一次，我就会告诉你猜的大了还是小了，直到猜中为止。你来想想，如何快速猜中我写的数字呢？ 假设我写的数字是 23，猜数过程如下。（如果猜测范围的数字有偶数个，中间数有两个，就选择较小的那个。） 例子2 假设有1000条订单数据，已经按照订单金额从小到大排序，每个订单金额不同，并且最小单位是元。我们现在想知道支付存在金额等
[力扣刷题总结](二分查找)
weixin_38800498的博客
01-01 738
文章目录||||||||||||||||||||||| 二分查找 ||||||||||||||||||||||||||||模板1：寻找一个数模板2：寻找左侧边界的二分搜索模板3：寻找左侧边界的二分搜索|||||||||||||| 标准二分查找一个数 |||||||||||||69. Sqrt(x)解法1：二分查找解法2：牛顿迭代法704. 二分查找解法1：二分查找||||||||||||||||||||||| 二分查找左边界 ||||||||||||||||||||||||||||278. 第一个错误的版.
查找----二分查找法
weixin_30904593的博客
08-25 199
1、二分查找法 二分查找法有一个很重要的前提条件：即待查找的序列必须是已经排好序的。 假设元素序列是按升序排列，将序列中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将序列分成前、后两个子序列，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子序列，否则进一步查找后一子序列。重复以上过程，直到找到满足条件的记录，查找成功，返回元素在序...
算法-二分查找
wyc的博客
07-23 423
二分查找 public int find(int[] nums, int target){ if (nums == null || nums.length == 0) return -1; int left = 0; int right = nums.length - 1; while (left <= right){ int middle = (left + right) / 2; if
Python搜索算法-二分查找算法详解
最新发布
04-10
Python搜索算法——二分查找算法详解
查找算法-二分查找详解
12-20
二分查找，也被称为折半查找，是一种在有序数组中高效地查找特定元素的搜索算法。这个算法充分利用了数组的线性存储结构，通过不断缩小查找范围，将查找时间复杂度降低到对数级别，极大地提高了查找效率。下面将详细...
二分查找算法PPT课件
04-11
二分查找算法，二分查找算法课件，二分查找算法PPT
C#-使用C#实现的二分查找算法-算法实现.zip
02-25
二分查找算法是一种在有序数组中查找特定元素的搜索算法，具有高效的时间复杂度，是计算机科学中的基础算法之一。本资源"**C#-使用C#实现的二分查找算法-算法实现.zip**"提供了使用C#语言实现二分查找算法的详细代码...
二分查找算法实现-修正1
08-04
二分查找算法实现-修正1 二分查找算法是计算机科学中一种常用的查找算法，通过将要查找的数组分成两半，并不断缩小查找范围来找到目标元素。该算法的实现可以在多种编程语言中使用，包括C++、Java、C#等。 在给定...
二分查找小结
weixin_42564710的博客
07-15 186
leecode经典二分查找题目和二分法变形问题总结 二分查找原理很简单，但是想要写出没有bug的二分查找并不容易。 废话不多说，先上题目： Leecode：33. 搜索旋转排序数组 注：代码中的end是可以取得到的索引值。 先从简单的二分查找开始吧，有序数组中不存在重复元素，则我们在给定数组nums中查找目标 target，若存在，返回索引；若不存在，返回-1。(python) def bis...
算法总结-二分查找算法
hhhlizhao的博客
11-15 3512
二分查找也称折半查找（Binary Search），是一种效率较高的查找方法。该算法要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。如果一个序列是无序的或者是链表，那么该序列就不能使用二分查找。 1、二分查找算法原理 二分查找算法原理如下： （1）若待查序列为空，则返回-1，并退出算法； （2）若待查序列不为空，则将它的中间元素与目标数值进行比较，判断是否相等； （3）若相等，则返回中间元素索引，并退出算法；此时已查找成功。 （4）若不相等，则比较中间元素与目标数值的大小；
算法分析与设计 二分查找
王清欢的博客
05-19 7598
算法分析与设计 二分查找 二分查找的基本概念 ​ 二分查找是一种在有序数组中查找某一特定元素的查找算法。这种查找方法将查找的时间复杂度从原本的线性时间提升到了对数时间范围，大大缩短了搜索时间。 ​ 二分查找的基本思想是：在查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则查找过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。 ​ 一个基本的二分查找示例如下，在如下数组中找出元素4所在
查找算法之二分查找
weixin_30376453的博客
08-29 95
参考 1. 二分查找法 | 博客园 二分查找 在有序的顺序表中查找元素，可以通过二分查找算法进行查找。 基本思想： 假设是递增序列（或者不减序列）， 先通过待查找顺序表的最左端元素索引left 和最右端元素索引right求得中间元素索引middle（ middle=(left+right)/2 ），然后将待查元素与中间元素比较。若待查元素>中间元素，则右移left至midd...
算法设计与分析——二分查找
A_FLY_User的博客
05-22 1496
目录前言一、算法思想介绍二、算法效率分析三、算法代码3.1 C语言3.2 JavaScript四、后记 前言 在真正的项目中，查找是一个必不可少的功能。在一堆数据中，查找从头开始某一个元素，如果运气好，那么前几次就能查到想要的元素。而最怕的往往是运气不好的情况，查找到最后一个才查找，甚至是最后一个都不是我们要查找的元素，这个时候是非常浪费性能的。 查找的算法有许多种，如果在这组数据是在排序好的情况下，那么二分查找会是一种非常高效的查找算法，但也仅限于该组数据排序好（亦或是有规律）的情况下。 一、算法思想介绍
【C++】二分查找
weixin_44697562的博客
04-24 150
前提 1.存储元素列表内的元素必须为有序的； 结果展示 代码部分 #include <iostream> using namespace std; void bisearch(int _find,int *_pArr,int _len) { //最小值 最大值 int mMin = 0, mMax = _len - 1; //中间值 int mMid = 0; while (mMin <= mMax) { mMid = (mMin + mMax) / 2; i
Seneca：NodeJS 微服务框架入门（一）
热门推荐
bob_baobao的博客
01-29 1万+
Seneca是什么？ （1）官网是这样介绍的： Seneca is a microservices toolkit for Node.js. It helps you write clean, organized code that you can scale and deploy at any time. 大概意思是：Seneca是一个库，在Node平台上开发微服务时用的，它能够帮助开发人员...
第14讲 二分查找与冒泡排序。.pptx
02-12
课程涵盖计算机基础、数据结构、算法简介等内容，特别关注二分查找和冒泡排序。二分查找是一种高效的查找算法，适用于有序数据，通过不断缩小查找范围来定位目标元素。冒泡排序则是一种简单的排序算法，通过不断交换...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值