二分查找

最新推荐文章于 2024-07-19 15:45:46 发布

可别让我逮住你乐

最新推荐文章于 2024-07-19 15:45:46 发布

阅读量91

点赞数

文章标签：算法 leetcode

本文链接：https://blog.csdn.net/weixin_46819249/article/details/120047100

版权

来源

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problemset/all/

二分查找

二分查找应用(简单）

35. 搜索插入位置

1. 问题

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为O(log n)的算法

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

示例 4:

输入: nums = [1,3,5,6], target = 0
输出: 0

示例 5:

输入: nums = [1], target = 0
输出: 0

2. 解决方案

因为要用O(log n)的时间复杂度，所以可以用二分查找
用二分查找可以解决，如果找不到目标，那最后的left就是目标按顺序应该插入的位置

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int middle, left = 0, right = nums.size() -1;
        while(left <= right)   // <= 是为了处理nums.size() == 1 的情况
        {
            middle = (right - left) /2 + left;
            if(nums[middle] == target)  return middle;
            if(target < nums[middle])   right = middle -1;
            else    left = middle + 1;
        }
        return left;		// left 就是目标按顺序应该插入的位置
    }
};

278. 第一个错误的版本

1. 问题

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

2. 解决方案

这个问题不同于上一个，当left == right时，我们就可以确定了，所以while里不用加等于

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        int middle, left = 1, right = n;
        while(left < right)	// 循环直至区间左右端点相同
        {
          middle = (right - left) / 2 + left;	// 防止计算时溢出
          if(isBadVersion(middle))  right = middle;	// 答案在区间 [left, mid] 中
          else left = middle +1;	// 答案在区间 [mid+1, right] 中
        }
        // 此时有 left == right，区间缩为一个点，即为答案
        return right;	
    }
};

367. 有效的完全平方数

1. 问题

给定一个正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
进阶：不要使用任何内置的库函数，如 sqrt

示例 1：

输入：num = 16
输出：true

示例 2：

输入：num = 14
输出：false

2. 解决方案

当用middle*middle时，因为发生了int型溢出，所以考虑middle == num/middle
因为当num=5时，5 / 2 =2.5会自动变成2，与2判断时，会被认为相同，报错
所以要添加num%middle == 0 的条件，表示可以整除

class Solution {
public:
    bool isPerfectSquare(int num) {

        int middle;
        int left = 1;
        int right = num;
        while(left <= right)
        {
            middle = (right - left)/2 + left;
            if( middle == num/middle && num % middle == 0) return true; 
            if( middle > num/middle) right = middle -1;
            else left = middle + 1;
        }
        return false;
    }
};

69. x的平方根

1. 问题

给你一个非负整数 x ，计算并返回 x 的平方根。

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

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2

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

2. 解决方案

由于 x 平方根的整数部分ans是满足 k^2 ≤x 的最大 k 值，因此我们可以对 k 进行二分查找，从而得到答案

class Solution {
public:
    int mySqrt(int x) {
        int left = 0, right = x;
        int middle,ans;
        while(left <= right)
        {
            middle = left + (right - left)/2;
            if((long long) middle*middle <= x)
            {
                ans = middle;
                left = middle + 1;
            }else{
                right = middle -1;
            }
        }
        return ans;
    }
};

441. 排列硬币

1. 问题

你总共有 n 枚硬币，你需要将它们摆成一个阶梯形状，第 k 行就必须正好有 k 枚硬币。

给定一个数字 n，找出可形成完整阶梯行的总行数。

n 是一个非负整数，并且在32位有符号整型的范围内。

示例 1:

n = 5

硬币可排列成以下几行:
¤
¤ ¤
¤ ¤

因为第三行不完整，所以返回2.

示例 2:

n = 8

硬币可排列成以下几行:
¤
¤ ¤
¤ ¤ ¤
¤ ¤

因为第四行不完整，所以返回3.

2. 解决方案

累加可以用 n*(n+1)/2 ,与上面那道题相似

class Solution {
public:
    int arrangeCoins(int n) {
        int left = 0, right = n;
        int middle, ans;
        while(left <= right)
        {
            middle = left + (right - left)/2;
            if((long long) middle*(middle+1)/2 <= n)
            {
                ans = middle;
                left = middle+1;
            }else{
                right = middle-1;
            }
        }
        return ans;
    }
};

二分查找应用（中等）

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

1. 问题

给定一个按照升序排列的整数数组 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]

2. 解决方案

因为这个数组已经是有序的，所以我们找到相同的目标值后，可以比较他的前后值，确定左右边界, 如果前后值还相等，可以缩小边界范围

class Solution {
public:
    int findside(vector<int>& nums, int target, string side)
    {
        int middle, left = 0, right = nums.size()-1;
        // 当没有找到时，要输出-1，故初始化为-1
        int out = -1;
        while(left <= right)
        {
            middle = left + (right - left)/2;
            if(target < nums[middle])  right = middle -1;
            if(target > nums[middle])  left = middle + 1;
            if(nums[middle] == target) 
            {
                if(side == "left")
                {
                    // 需要加mid == 0， 避免0-1 越界错误
                    if(middle == 0 || nums[middle-1] != target)
                    {
                         out = middle;
                         break;
                    }  
                    else 
                    // 因为是寻找左边界，故保留左半边
                        right = middle-1;
                }
                if(side == "right")
                {
                    if(middle == nums.size()-1 || nums[middle+1] != target)
                    {
                        out = middle;
                        break;
                    } 
                    else 
                        left = middle+1;
                }
            }
        }
        return out;
    }
    vector<int> searchRange(vector<int>& nums, int target) {
            int left = findside(nums, target, "left");
            int right = findside(nums, target, "right");
            // vector<int> location;
            // location.push_back(left);
            // location.push_back(right);
            // return location;
            return {left, right};
    }
};

540. 有序数组中的单一元素

1. 问题

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。

示例 1:

输入: nums = [1,1,2,3,3,4,4,8,8]
输出: 2

示例 2:

输入: nums =  [3,3,7,7,10,11,11]
输出: 10

2. 解决方案

排除数组为空、在最左边和最右边的情况，然后就剩下在中间的情况
比较中值与左右值，若不同，则得到目标，直接返回

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
    
    	if(nums.size() == 1) return nums[0];
       	if(nums[0] != nums[1])   return nums[0];
       	if(nums[nums.size() -1] != nums[nums.size() -2])  return nums[nums.size() -1];
       	
       int middle, left = 0, right = nums.size()-1;
       int out = -1;
       while(left <= right)
       {
           middle = left + (right - left)/2;
           if(nums[middle] != nums[middle+1] && nums[middle] != nums[middle -1]) 
           {
               out = nums[middle];
               break;
           }
           // 左边相等
           if(nums[middle] == nums[middle -1])
           {
           	// 假设目标值在左边，则 按 1 1 2  4 【4】 的顺序（加【】表示是中值），	
           	// middle是偶数，从0开始计数
               if((middle&1) == 0)    right = middle - 2;
               else left = middle +1;
           }
            // 右边相等
            if(nums[middle] == nums[middle + 1])
            {
            // 假设目标值在左边，则 按 1 1 2 【4】 4 的顺序（加【】表示是中值），	
           	// middle是奇数
                if((middle&1) != 0)  right = middle -1;
                else left = middle + 2;
            }
       } 
       return out;
    }
};

动态规划

300. 最长递增子序列

1. 问题

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]
输出：4

解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。
示例 2：

输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]
输出：1

2. 解决方案

动态规划
考虑前 i 个元素，取第 i 个数字结尾的最长上升子序列的长度，注意 nums[i] 必须被选取。
将子串前面中的每一个元素与nums[i] 比较，若小于nums[i]，则nums[i]这个元素可以与那个元素组合，则进行比较 dp[i] = max(dp[i], dp[j] + 1);

int test()
{
    vector<int> nums;
    nums = {10,9,2,5,3,7,101,18};

    int n = nums.size();
    if(n == 0) return 0;
    vector<int> dp(n, 1);
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<i; j++)
        {
            if(nums[j] < nums[i])
            {
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
    }

    for(vector<int>::iterator it = dp.begin(); it != dp.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;       // 1 1 1 2 2 3 4 4 

    // 查询最大值的第一个位置
    // max_element(begin,end);
    // 查询最小值的第一个位置
    // min_element(begin, end);
    
    // 输出最大值
    cout << *max_element(dp.begin(), dp.end()); // 4
}