【leetcode边做边学】二分查找应用

更多请关注我的HEXO博客：http://jasonding1354.github.io/

简书主页：http://www.jianshu.com/users/2bd9b48f6ea8/latest_articles

二分查找

二分查找算法是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组 为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。折半搜索每次把搜索区域减少一半，时间复杂度为Ο(logn)。

二分查找的优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，二分查找，是通过不断缩小解可能存在的范围，从而求得问题最优解的方法，适用于不经常变动而查找频繁的有序列表。

二分查找算法要求

  1. 必须采用顺序存储结构
  2. 必须按关键字大小有序排列

二分查找算法流程图

二分查找流程图

二分查找c源码

//二分查找的递归版本
int binary_search_recursion(const int array[], int low, int high, int key)
{
    int mid = low + (high - low)/2;
    if(low > high)
        return -1;
    else{
        if(array[mid] == key)
            return mid;
        else if(array[mid] > key)
            return binary_search_recursion(array, low, mid-1, key);
        else
            return binary_search_recursion(array, mid+1, high, key);
    }
}  

//二分查找的循环版本
int binary_search_loop(const int array[], int len, int key)
{
    int low = 0;
    int high = len - 1;
    int mid;
    while(low <= high){
        mid = (low+high) / 2;
        if(array[mid] == key)
            return mid;
        else if(array[mid] > key)
            high = mid - 1;
        else
            low = mid + 1;
    }
    return -1;
}

边界错误

二分查找算法的边界一般分为两种情况，一种为左闭右开区间，如[low,high)，一种是左闭右闭区间，如[low,high]。这里需要注意的是循环体外的初始化条件，与循环体内的迭代步骤，都必须遵守一致的区间规则，也就是说，如果循环体初始化时，是以左闭右开区间为边界的，那么循环体内部的迭代也应该如此。

Leetcode实例

Search in Rotated Sorted Array

要求

Suppose a sorted array is rotated at some pivot unknown to you beforehand

假设有一排好序的数组，它事先在某个轴心点处被旋转

(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2 )

You are given a target value to search.

If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

分析

二分查找，难度在于左右边界的确定

如果A[middle] <= A[first]，则[middle,last-1]区间的子数组为递增序列，那它就可以用二分查找的方法去进行查询；否则，就会被继续的划分，知道子数组是一个递增的数组为止。反之也是同样的道理。

由于last一直指向子数组最后一个元素的下一个位置，所以在程序的赋值是要特别注意。

C++代码

class Solution {
public:
    int search(int A[], int n, int target) {
        int first = 0;
        int last = n;
        while(first != last)
        {
            int middle = (first + last)/2;
            if(A[middle] == target)
                return middle;
            if(A[first] >= A[middle]){
                if(target > A[middle] && target <= A[last-1])
                    first = middle+1;
                else
                    last = middle;
            }
            else
            {
                if(target < A[middle] && target >= A[first])
                    last = middle;
                else
                    first = middle+1;
            }
        }
        return -1;
    }
};

Search in Rotated Sorted Array II

要求

Follow up for ”Search in Rotated Sorted Array”: What if duplicates are allowed?

Write a function to determine if a given target is in the array.

作为上一题的变型，该题允许存在重复的元素

分析

允许重复元素，则上一题中如果 A[middle]>=A[left], 那么 [left,middle] 为递增序列的假设就不能成立了，比如 [1,3,1,1,1]。

如果 A[m]>=A[l] 不能确定递增，那就把它拆分成两个条件：

  • 若 A[m]>A[l]，则区间 [l,m] 一定递增
  • 若 A[m]==A[l] 确定不了，那就 l++，往下看一步即可。

    c++代码

    class Solution {
public:
  bool search(int A[], int n, int target) {
      int first = 0,last = n;
      while(first != last)
      {
          int mid = (first+last)/2;
          if(A[mid] == target)
              return true;
          if(A[mid] == A[first])
              first++;
          else if(A[mid] > A[first])
          {
              if(A[first]<= target && A[mid] > target)
                  last = mid;
              else
                  first = mid+1;
          }
          else
          {
              if(A[mid] < target && A[last-1] >= target)
                  first = mid+1;
              else
                  last = mid;
          }
      }
      return false;
  }
};

二分查找思想的应用

求最优解问题

二分查找的方法在求最优解的问题上也很有用。比如“求满足某个条件C(x)的最小的x”这一问题。对于任意满足C(x)的x如果所有x‘>=x也满足C(x‘)的话，就可以用二分查找来求得最小的x。

首先我们将区间的左端点初始化为不满足C(x)的值，右端点初始化为满足C(x)的值。然后每次取中点mid=(lb+ub)/2,判断C(mid)是否满足并缩小范围，直到(lb,ub]足够小为止。最后ub就是要求的最小值。

同理，最大化的问题也可以用同样的方法求解。

假定一个解并判断是否可行

有N条绳子，他们长度分别为Li。如果从它们中切割出K条长度相同的绳子的话，这K条绳子每条最长能有多长？答案保留到小数点后2位。

限制条件：

  • 1<= N <= 10000
  • 1<= K <= 10000
  • 1<= Li <= 100000

分析

令条件为C(x)=可以得到K条长度为x的绳子

则问题变为求满足C(x)条件的最大的x。在区间初始化时，令下界为lb=0，上界为ub=INF。

转化：

由于长度为Li 的绳子最多可以切出floor(Li/x)段长度为x的绳子，因此

C(x)=(floor(Li/x)的总和是否大于或者等于K)

代码实例

#include <iostream>
#include <math.h>
using namespace std;
#define MAX_N 10

int N = 4;
int K = 10;
double L[MAX_N] = {8.02,7.43,4.57,5.39};

bool C(double x)
{
    int num = 0;
    for(int i=0;i<N;i++)
    {
        num += (int)(L[i]/x);
    }
    return num >= K;
}

void solve()
{
    double lb = 0;
    double ub = 1000;
    for(int i=0;i<100;i++)
    {
        double mid = (lb+ub)/2;
        if(C(mid)) lb = mid;
        else ub = mid;
    }
    cout << floor(ub*100)/100<<endl;
}

int main() {
    solve();
    return 0;
}

二分查找的结束判定

在输出小数的问题中，一般都会制定允许的误差范围或者制定输出中小数点后面的位数。有必要设置合理的结束条件来满足精度的要求。

在上面的程序中，我们制定循环次数作为终止条件。1次循环可以吧区间范围缩小一半，100次循环则可以达到10的-30次幂的精度范围，基本是没有问题的。

最大化平均值

有n个物品的重量和价值分别是wi和vi。从中选出k个物品使得单位重量的价值最大。

限制条件：

  • 1<= k <= n <= 10^4
  • 1<= wi,vi <= 10^6

分析

最大化平均值

代码实例

//input
int n,k;
int w[MAX_N],v[MAX_N];

double y[MAX_N];// v - x * w

bool C(double x)
{
    for(int i=0;i<n;i++){
        y[i] = v[i] - x*w[i];
    }
    sort(y,y+n);
    //compute the sum of top-k number(array y)
    double sum = 0;
    for(int i=0;i<k;i++){
        sum+=y[n-i-1];
    }
    return sum >= 0;
}
void solve()
{
    double lb=0,ub=INF;
    for(int i=0;i<100;i++){
        double mid = (lb+ub)/2;
        if(C(mid))
            lb = mid;
        else
            ub = mid;
    }
    printf("%.2f\n",ub);
}
时间： 2024-09-28 19:15:18

【leetcode边做边学】二分查找应用的相关文章

Leetcode 35 Search Insert Position 二分查找（二分下标）

基础题之一,是混迹于各种难题的基础,有时会在小公司的大题见到,但更多的是见于选择题... 题意:在一个有序数列中,要插入数target,找出插入的位置. 楼主在这里更新了<二分查找综述>第一题的解法,比较类似,当然是今天临时写的. 知道了这题就完成了leetcode 4的第二重二分的写法了吧,楼主懒... 1 class Solution { 2 public: 3 int searchInsert(vector<int>& nums, int target) { 4 in

[C++]LeetCode: 118 Find Peak Element (二分查找 寻找数组局部峰值)

题目: A peak element is an element that is greater than its neighbors. Given an input array where num[i] ≠ num[i+1], find a peak element and return its index. The array may contain multiple peaks, in that case return the index to any one of the peaks i

Leetcode题解——算法思想之二分查找

1. 求开方 2. 大于给定元素的最小元素 3. 有序数组的 Single Element 4. 第一个错误的版本 5. 旋转数组的最小数字 6. 查找区间 正常实现 Input : [1,2,3,4,5] key : 3 return the index : 2 public int binarySearch(int[] nums, int key) { int l = 0, h = nums.length - 1; while (l <= h) { int m = l + (h - l) /

Leetcode 278 First Bad Version 二分查找

题意:找到第一个出问题的版本 二分查找,注意 mid = l + (r - l + 1) / 2;因为整数会溢出 1 // Forward declaration of isBadVersion API. 2 bool isBadVersion(int version); 3 4 class Solution { 5 public: 6 int firstBadVersion(int n) { 7 int l = 1, r = n , ans ; 8 while(l <= r){ 9 int m

LeetCode Search Insert Position （二分查找）

题意: 给一个升序的数组,如果target在里面存在了,返回其下标,若不存在,返回其插入后的下标. 思路: 来一个简单的二分查找就行了,注意边界. 1 class Solution { 2 public: 3 int searchInsert(vector<int>& nums,int target) 4 { 5 int L=0, R=nums.size(); 6 while(L<R) 7 { 8 int mid=R-(R-L+1)/2; 9 if(nums[mid]>=t

leetcode 69题 思考关于二分查找的模版

leetcode 69, Implement int sqrt(int x). Compute and return the square root of x, where x is guaranteed to be a non-negative integer. Since the return type is an integer, the decimal digits are truncated and only the integer part of the result is retu

Leetcode 162 Find Peak Element (二分查找思想)

A peak element is an element that is greater than its neighbors. Given an input array where num[i] ≠ num[i+1], find a peak element and return its index. The array may contain multiple peaks, in that case return the index to any one of the peaks is fi

二分查找总结

最近刷leetcode和lintcode,做到二分查找的部分,发现其实这种类型的题目很有规律,题目大致的分为以下几类: 1.最基础的二分查找题目,在一个有序的数组当中查找某个数,如果找到,则返回这个数在数组中的下标,如果没有找到就返回-1或者是它将会被按顺序插入的位置.这种题目继续进阶一下就是在有序数组中查找元素的上下限.继续做可以求两个区间的交集. 2.旋转数组问题,就是将一个有序数组进行旋转,然后在数组中查找某个值,其中分为数组中有重复元素和没有重复元素两种情况. 3.在杨氏矩阵中利用二分查

leetcode旋转数组查找 二分查找的变形

http://blog.csdn.net/pickless/article/details/9191075 Suppose a sorted array is rotated at some pivot unknown to you beforehand. (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2). You are given a target value to search. If found in the array return it