查找算法-二分查找

Posted 夜忙猪

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了查找算法-二分查找相关的知识，希望对你有一定的参考价值。

算法思想

二分查找也称折半查找（Binar Search)，是一种在 有序数组中查找某一特定元素的搜索算法。
搜索过程：

  • 从数组的中间开始搜索，如果中间的元素正好是要查找的元素，则搜索过程结束。

  • 如果该值大于中间元素，则在数组大于中间的那一半查找。

  • 如果该值小于中间元素，则在数组小于中间的那一半查找。

  • 而且再次查找的过程回到第一步，在该部分的中间元素开始。直到找到该元素或者数组为空。

其时间的复杂度为O（logn），空间复杂度o（1）

二分法很容易理解，但是细节是魔鬼，要写出一个正确的二分法不是一件容易的事情。

算法实现

首先我们了解一下其基本的实现，nums为有序数组，len为其长度，target为要寻找的目标

 
   
   
 
    
  
    
    
  
  1. // 寻找一个数,如果存在返回其索引，否则返回-1。
    2. 
  
    
    
  
  2. int binarySearch(int* nums, int len, int target)
    3. 
  
    
    
  
  3. {
    4. 
  
    
    
  
  4.  int left = 0;
    5. 
  
    
    
  
  5.  int right = len - 1;
    6. 
  
    
    
  

    7. 
  
    
    
  
  7.  while (left <= right) {
    8. 
  
    
    
  
  8.  int mid = left + (right - left) / 2;
    9. 
  
    
    
  
  9.  if (nums[mid] == target) {
    10. 
  
    
    
  
  10.  return mid;
    11. 
  
    
    
  
  11.  } else if (nums[mid] < target) {
    12. 
  
    
    
  
  12.  left = mid + 1;
    13. 
  
    
    
  
  13.  } else if (nums[mid] > target) {
    14. 
  
    
    
  
  14.  right = mid - 1;
    15. 
  
    
    
  
  15.  }
    16. 
  
    
    
  
  16.  }
    17. 
  
    
    
  
  17.  return -1;
    18. 
  
    
    
  
  18. }
    19.

当然我们也要学会拒绝造轮子嘛 O(∩_∩)O

包含这个头文件 我们就可以使用库函数了。

void bsearch(const void *key, const void *base, size_t nitems, size_t size, int (compare)(const void , const void));
key -- 要查找的元素
base -- 指向要排序的数组的第一个元素的指针。
nitems -- 由 base 指向的数组中元素的个数。
size-- 数组中每个元素的大小，以字节为单位。
compare -- 用来比较两个元素的函数，即函数指针（回调函数）

 
   
   
 
    
  
    
    
  
  1. #include <stdlib.h>
    2. 
  
    
    
  
  2. #define ARRAY_SIZE 5
    3. 
  
    
    
  
  3. int values[ARRAY_SIZE] = { 32, 32, 32, 32, 32 };
    4. 
  
    
    
  

    5. 
  
    
    
  
  5. // compare函数
    6. 
  
    
    
  
  6. int cmpfunc(const void* a, const void* b)
    7. 
  
    
    
  
  7. {
    8. 
  
    
    
  
  8.  return (*(int*)a - *(int*)b);
    9. 
  
    
    
  
  9. }
    10. 
  
    
    
  
  10. int main()
    11. 
  
    
    
  
  11. {
    12. 
  
    
    
  
  12.  int* item;
    13. 
  
    
    
  
  13.  int res;
    14. 
  
    
    
  
  14.  int key = 32;
    15. 
  
    
    
  

    16. 
  
    
    
  
  16.  item = (int*)bsearch(&key, values, ARRAY_SIZE, sizeof(int), cmpfunc);
    17. 
  
    
    
  
  17.  printf("lib index =%d\n", (int)(item - values) < 0 ? -1 : (int)(item - values)); //如果存在输出其索引，否则输出-1
    18. 
  
    
    
  

    19. 
  
    
    
  
  19.  return (0);
    20. 
  
    
    
  
  20. }
    21.

有时候我们可能想要最先出现的那个值，那么就需要我们把左值找出来

寻找左侧边界

 
   
   
 
    
  
    
    
  
  1. // 寻找左侧边界
    2. 
  
    
    
  
  2. int leftBoundSearch(int* nums, int len, int target)
    3. 
  
    
    
  
  3. {
    4. 
  
    
    
  
  4.  if (len == 0) {
    5. 
  
    
    
  
  5.  return -1;
    6. 
  
    
    
  
  6.  }
    7. 
  
    
    
  
  7.  int left = 0;
    8. 
  
    
    
  
  8.  int right = len;
    9. 
  
    
    
  
  9.  while (left < right) {
    10. 
  
    
    
  
  10.  int mid = left + (right - left) / 2;
    11. 
  
    
    
  
  11.  if (nums[mid] == target) {
    12. 
  
    
    
  
  12.  right = mid;
    13. 
  
    
    
  
  13.  } else if (nums[mid] < target) {
    14. 
  
    
    
  
  14.  left = mid + 1;
    15. 
  
    
    
  
  15.  } else if (nums[mid] > target) {
    16. 
  
    
    
  
  16.  right = mid;
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  
  18.  }
    19. 
  
    
    
  
  19.  if (left == len) {
    20. 
  
    
    
  
  20.  return -1;
    21. 
  
    
    
  
  21.  } else {
    22. 
  
    
    
  
  22.  return nums[left] == target ? left : -1;
    23. 
  
    
    
  
  23.  }
    24. 
  
    
    
  
  24. }
    25.

有时候我们可能想要最后出现的那个值，那么就需要我们把右值找出来

寻找右侧边界

 
   
   
 
    
  
    
    
  
  1. // 寻找右侧边界
    2. 
  
    
    
  
  2. int rightBoundSearch(int* nums, int len, int target)
    3. 
  
    
    
  
  3. {
    4. 
  
    
    
  
  4.  if (len == 0) {
    5. 
  
    
    
  
  5.  return -1;
    6. 
  
    
    
  
  6.  }
    7. 
  
    
    
  
  7.  int left = 0;
    8. 
  
    
    
  
  8.  int right = len;
    9. 
  
    
    
  
  9.  while (left < right) {
    10. 
  
    
    
  
  10.  int mid = left + (right - left) / 2;
    11. 
  
    
    
  
  11.  if (nums[mid] == target) {
    12. 
  
    
    
  
  12.  left = mid + 1;
    13. 
  
    
    
  
  13.  } else if (nums[mid] < target) {
    14. 
  
    
    
  
  14.  left = mid + 1;
    15. 
  
    
    
  
  15.  } else if (nums[mid] > target) {
    16. 
  
    
    
  
  16.  right = mid;
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  
  18.  }
    19. 
  
    
    
  
  19.  if (left == 0) {
    20. 
  
    
    
  
  20.  return -1;
    21. 
  
    
    
  
  21.  } else {
    22. 
  
    
    
  
  22.  return nums[left - 1] == target ? (left - 1) : -1;
    23. 
  
    
    
  
  23.  }
    24. 
  
    
    
  
  24. }
    25.

那么我们放到一起来体验一下把

 
   
   
 
    
  
    
    
  
  1. /* 使用 二分法 在数组中查找值 32 */
    2. 
  
    
    
  

    3. 
  
    
    
  
  3. #include <stdio.h>
    4. 
  
    
    
  
  4. #include <stdlib.h>
    5. 
  
    
    
  

    6. 
  
    
    
  
  6. #define ARRAY_SIZE 5
    7. 
  
    
    
  

    8. 
  
    
    
  
  8. int values[ARRAY_SIZE] = { 32, 32, 32, 32, 32 };
    9. 
  
    
    
  

    10. 
  
    
    
  
  10. // compare函数
    11. 
  
    
    
  
  11. int cmpfunc(const void* a, const void* b)
    12. 
  
    
    
  
  12. {
    13. 
  
    
    
  
  13.  return (*(int*)a - *(int*)b);
    14. 
  
    
    
  
  14. }
    15. 
  
    
    
  

    16. 
  
    
    
  
  16. // 寻找一个数,如果存在返回其索引，否则返回-1。
    17. 
  
    
    
  
  17. int binarySearch(int* nums, int len, int target)
    18. 
  
    
    
  
  18. {
    19. 
  
    
    
  
  19.  int left = 0;
    20. 
  
    
    
  
  20.  int right = len - 1;
    21. 
  
    
    
  

    22. 
  
    
    
  
  22.  while (left <= right) {
    23. 
  
    
    
  
  23.  int mid = left + (right - left) / 2;
    24. 
  
    
    
  
  24.  if (nums[mid] == target) {
    25. 
  
    
    
  
  25.  return mid;
    26. 
  
    
    
  
  26.  } else if (nums[mid] < target) {
    27. 
  
    
    
  
  27.  left = mid + 1;
    28. 
  
    
    
  
  28.  } else if (nums[mid] > target) {
    29. 
  
    
    
  
  29.  right = mid - 1;
    30. 
  
    
    
  
  30.  }
    31. 
  
    
    
  
  31.  }
    32. 
  
    
    
  
  32.  return -1;
    33. 
  
    
    
  
  33. }
    34. 
  
    
    
  
  34. // 寻找左侧边界
    35. 
  
    
    
  
  35. int leftBoundSearch(int* nums, int len, int target)
    36. 
  
    
    
  
  36. {
    37. 
  
    
    
  
  37.  if (len == 0) {
    38. 
  
    
    
  
  38.  return -1;
    39. 
  
    
    
  
  39.  }
    40. 
  
    
    
  
  40.  int left = 0;
    41. 
  
    
    
  
  41.  int right = len;
    42. 
  
    
    
  
  42.  while (left < right) {
    43. 
  
    
    
  
  43.  int mid = left + (right - left) / 2;
    44. 
  
    
    
  
  44.  if (nums[mid] == target) {
    45. 
  
    
    
  
  45.  right = mid;
    46. 
  
    
    
  
  46.  } else if (nums[mid] < target) {
    47. 
  
    
    
  
  47.  left = mid + 1;
    48. 
  
    
    
  
  48.  } else if (nums[mid] > target) {
    49. 
  
    
    
  
  49.  right = mid;
    50. 
  
    
    
  
  50.  }
    51. 
  
    
    
  
  51.  }
    52. 
  
    
    
  
  52.  if (left == len) {
    53. 
  
    
    
  
  53.  return -1;
    54. 
  
    
    
  
  54.  } else {
    55. 
  
    
    
  
  55.  return nums[left] == target ? left : -1;
    56. 
  
    
    
  
  56.  }
    57. 
  
    
    
  
  57. }
    58. 
  
    
    
  
  58. // 寻找右侧边界
    59. 
  
    
    
  
  59. int rightBoundSearch(int* nums, int len, int target)
    60. 
  
    
    
  
  60. {
    61. 
  
    
    
  
  61.  if (len == 0) {
    62. 
  
    
    
  
  62.  return -1;
    63. 
  
    
    
  
  63.  }
    64. 
  
    
    
  
  64.  int left = 0;
    65. 
  
    
    
  
  65.  int right = len;
    66. 
  
    
    
  
  66.  while (left < right) {
    67. 
  
    
    
  
  67.  int mid = left + (right - left) / 2;
    68. 
  
    
    
  
  68.  if (nums[mid] == target) {
    69. 
  
    
    
  
  69.  left = mid + 1;
    70. 
  
    
    
  
  70.  } else if (nums[mid] < target) {
    71. 
  
    
    
  
  71.  left = mid + 1;
    72. 
  
    
    
  
  72.  } else if (nums[mid] > target) {
    73. 
  
    
    
  
  73.  right = mid;
    74. 
  
    
    
  
  74.  }
    75. 
  
    
    
  
  75.  }
    76. 
  
    
    
  
  76.  if (left == 0) {
    77. 
  
    
    
  
  77.  return -1;
    78. 
  
    
    
  
  78.  } else {
    79. 
  
    
    
  
  79.  return nums[left - 1] == target ? (left - 1) : -1;
    80. 
  
    
    
  
  80.  }
    81. 
  
    
    
  
  81. }
    82. 
  
    
    
  

    83. 
  
    
    
  
  83. // main
    84. 
  
    
    
  
  84. int main()
    85. 
  
    
    
  
  85. {
    86. 
  
    
    
  
  86.  int* item;
    87. 
  
    
    
  
  87.  int res;
    88. 
  
    
    
  
  88.  int key = 112;
    89. 
  
    
    
  

    90. 
  
    
    
  
  90.  item = (int*)bsearch(&key, values, ARRAY_SIZE, sizeof(int), cmpfunc);
    91. 
  
    
    
  
  91.  printf("lib index =%d\n", (int)(item - values) < 0 ? -1 : (int)(item - values));
    92. 
  
    
    
  

    93. 
  
    
    
  
  93.  res = binarySearch(values, ARRAY_SIZE, key);
    94. 
  
    
    
  
  94.  printf("std index =%d\n", res);
    95. 
  
    
    
  

    96. 
  
    
    
  
  96.  res = leftBoundSearch(values, ARRAY_SIZE, key);
    97. 
  
    
    
  
  97.  printf("lft index =%d\n", res);
    98. 
  
    
    
  

    99. 
  
    
    
  
  99.  res = rightBoundSearch(values, ARRAY_SIZE, key);
    100. 
  
    
    
  
  100.  printf("rgt index =%d\n", res);
    101. 
  
    
    
  
  101.  return (0);
    102. 
  
    
    
  
  102. }
    103. 
 
   
   
 
 
   
   
 
    
  
    
    
  
  1. lib index =2
    2. 
  
    
    
  
  2. std index =2
    3. 
  
    
    
  
  3. lft index =0
    4. 
  
    
    
  
  4. rgt index =4
    5.

光说不练假把式

我们在leetcode上来找两个例题试试手。

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

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

你的算法时间复杂度必须是 O(log n) 级别。

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

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8 输出: [3,4] 示例 2:

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

这个很明显的就是要用二分法嘛，虽然官方给了两个方法

1：线性扫描方法

2：二分查找

但是方法一线性扫描时间复杂度肯定不满足嘛，相信用上面的例子很容易改出答案来。

875. 爱吃香蕉的珂珂

我们再看一个不是特别明显的例子。

珂珂喜欢吃香蕉。这里有 N 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警卫已经离开了，将在 H 小时后回来。

珂珂可以决定她吃香蕉的速度 K （单位：根/小时）。每个小时，她将会选择一堆香蕉，从中吃掉 K 根。如果这堆香蕉少于 K 根，她将吃掉这堆的所有香蕉，然后这一小时内不会再吃更多的香蕉。  

珂珂喜欢慢慢吃，但仍然想在警卫回来前吃掉所有的香蕉。

返回她可以在 H 小时内吃掉所有香蕉的最小速度 K（K 为整数）。

 

示例 1：

输入: piles = [3,6,7,11], H = 8 输出: 4 示例 2：

输入: piles = [30,11,23,4,20], H = 5 输出: 30 示例 3：

输入: piles = [30,11,23,4,20], H = 6 输出: 23

题解

 
   
   
 
    
  
    
    
  
  1. int cmp(const void* a, const void* b) {
    2. 
  
    
    
  
  2.  return *(int*)a - *(int*)b;
    3. 
  
    
    
  
  3. }
    4. 
  
    
    
  
  4. int minEatingSpeed(int* piles, int pilesSize, int H){
    5. 
  
    
    
  

    6. 
  
    
    
  
  6.  qsort(piles, pilesSize, sizeof(int), cmp);//先排成有序数组
    7. 
  
    
    
  
  7.  / * 二分法查找左值 */
    8. 
  
    
    
  
  8.  int left = 1; ;
    9. 
  
    
    
  
  9.  int right = piles[pilesSize-1];
    10. 
  
    
    
  
  10.  int mid;
    11. 
  
    
    
  
  11.  int time=0;
    12. 
  
    
    
  
  12.  while (left < right) {
    13. 
  
    
    
  
  13.  mid = (left + right) / 2;
    14. 
  
    
    
  
  14.  time = 0;
    15. 
  
    
    
  
  15.  for (int i=0; i<pilesSize; i++) {
    16. 
  
    
    
  
  16.  time += (piles[i] + (mid - 1)) / mid;
    17. 
  
    
    
  
  17.  }
    18. 
  
    
    
  
  18.  if (time > H)
    19. 
  
    
    
  
  19.  left = mid + 1;
    20. 
  
    
    
  
  20.  else
    21. 
  
    
    
  
  21.  right = mid;
    22. 
  
    
    
  
  22.  }
    23. 
  
    
    
  
  23.  return left;
    24. 
  
    
    
  
  24. }
    25.


以上是关于查找算法-二分查找的主要内容，如果未能解决你的问题，请参考以下文章

「算法笔记」一文摸秃二分查找

PHP实现二分查找算法（代码详解）

二分查找算法讲解及其C++代码实现

leetcode查找算法（顺序查找，二分法，斐波那契查找，插值查找，分块查找）

算法——二分查找

二分查找--整理