个人主页：C++忠实粉丝
欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 C++忠实粉丝 原创

二分查找算法(1) _二分查找模板

收录于专栏【经典算法练习】
本专栏旨在分享学习算法的一点学习笔记，欢迎大家在评论区交流讨论💌

1. 二分查找算法简介

二分查找是一种在已排序数组中高效查找目标值的算法。其核心思想是通过不断将查找范围分成两部分，利用中间元素与目标值的比较来缩小范围。具体步骤如下：

1. 初始设定：设定两个指针，分别指向数组的起始和结束位置。
2. 计算中间位置：计算中间索引，并与目标值进行比较。
3. 比较结果：
        如果中间元素等于目标值，查找成功。
        如果目标值小于中间元素，调整结束指针，缩小到左半部分。
        如果目标值大于中间元素，调整起始指针，缩小到右半部分。
4. 重复：重复上述步骤，直到找到目标值或范围为空。
这种方法的时间复杂度为O(log n)，使其在大数据集中非常高效。

2. 题目链接:

OJ链接:二分查找

3. 题目描述 :

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9输出: 4
解释: 9 出现在 nums中并且下标为 4

示例 2:

输入: nums= [-1,0,3,5,9,12], target= 2输出: -1
解释: 2 不存在 nums中因此返回 -1

提示：

1. 你可以假设 nums 中的所有元素是不重复的。
2. n 将在 [1, 10000]之间。
3. nums 的每个元素都将在 [-9999, 9999]之间。

注意:

我们这道题的二分查找中的数据都是不重复的且有序 

4. 解法 :

    解法一:暴力枚举遍历:

    算法思路 :

遍历整个数组寻找target

    代码展示 :

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int ret = -1;
        auto i = nums.begin();
        for(i = nums.begin(); i < nums.end(); i++)
            if(*i == target) ret = i - nums.begin();
        return ret;
    }
};

 

    结果分析 :

用vector的迭代器直接遍历整个数组,我们的时间复杂度为O(N) 

    对暴力算法的反思与优化 :

我们的暴力算法虽然容易想,但是时间复杂度不是很好,而且我们的暴力算法完全没有利用题目中数组是有序的这一个条件,所以我们可以进一步优化.

 

这里假设我们先从4开始查找,假设我们的target比4大,那4的左边不就都可以舍去吗?这不就让我们简化了一些不必要的遍历吗? 

    解法二: 二分查找 :

    算法思路 :

a.定义 left ， right 指针，分别指向数组的左右区间。
b.找到待查找区间的中间点 mid ，找到之后分三种情况讨论：
        i.arr[mid] == target 说明正好找到，返回 mid 的值；
        ii.arr[mid] > target 说明[mid, right] 这段区间都是⼤于 target 的，因此舍
去右边区间，在左边[left, mid - 1] 的区间继续查找，即让 right = mid -
1 ，然后重复 2 过程；
        iii.arr[mid] < target 说明[left, mid] 这段区间的值都是⼩于 target 的，因
    此舍去左边区间，在右边[mid + 1, right] 区间继续查找，即让 left = mid +
    1 ，然后重复 2 过程；
c.当 left 与 right 错开时，说明整个区间都没有这个数，返回 - 1 。

注意:

这里其实我们找三等分点也可以成功,我们的二分查找其实就是利用数组的二段性,将一个数组分成两部分,然后舍去其中一部分,然后在另一部分中查找

之所以叫二分查找,是因为找二等分点的时间复杂度最低

    代码展示 :

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left= 0, right = nums.size() - 1;
        while(left <= right)
        {
            //防溢出
            int mid = left + (right - left) / 2;
            if(nums[mid] > target) right = mid - 1;
            else if(nums[mid] < target) left = mid + 1;
            else return mid;
        }
        return -1;
    }
};

 

三等分点查找

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left= 0, right = nums.size() - 1;
        while(left <= right)
        {
            //防溢出
            int mid = left + (right - left) / 3;
            if(nums[mid] > target) right = mid - 1;
            else if(nums[mid] < target) left = mid + 1;
            else return mid;
        }
        return -1;
    }
};

 

    结果分析 :

二分查找时间复杂度分析:   

 二分查找的时间复杂度可以通过分析其每一步操作来证明。具体分析如下：

    初始条件：二分查找在一个已排序的数组中进行搜索，假设数组长度为n

    每次操作：在每一次迭代中，算法都会计算中间索引 mid，并根据与目标值的比较来决定下一步搜索的范围。每次迭代都将当前搜索范围减半。

    减半过程：

    首先，搜索的范围是n（整个数组）。
    第一次迭代后，范围缩小到n / 2。
    第二次迭代后，范围缩小到n / 4。
    第三次迭代后，范围缩小到n / 8。
    ...
    这个过程会一直持续，直到范围缩小到 1。
    结束条件：当搜索范围缩小到 0（即 left > right）时，算法结束。每次迭代都将问题规模减半，因此我们可以得到以下关系：

        n, n/2, n/4, n/8, ......, 1;

    数学推导：设迭代次数为k，那么在第k 次迭代时，范围大小为：

        n/2^k = 1

    解这个方程，可以得到：

        n = 2^k ----> k = log2(n)

    时间复杂度：因此，二分查找的时间复杂度是O(logn)，因为它的迭代次数与输入规模的对数成正比。

    总结：二分查找在每一步中通过将搜索范围减半，有效地减少了需要检查的元素数量，因此其时间复杂度为O(logn)。

5. 二分算法模板总结

while(left <= right)
{
	int mid = left + (right - left) / 2;
	if (....)
		left = mid + 1;
	else if (....)
		right = mid - 1;
	else
		return ...;
}