二分查找算法小结

二分查找

🛐线性枚举

线性枚举问题类型

给定一个单调不降的有序数组如下所示,要求找到如下要求的元素

1)>6的最小数的下标位置

2)>=6的最小数的下标位置

3)<6的最大数下标位置

4)<=6的最大数的下标位置

012345678
134666789
3241
/*
 本函数将在线性枚举过程中多次调用,起到判断作用
*/
int compare_fun(int num, int target) {   // num为遍历到的数,target在本题中为6
   return num > target;    // ---1
   return num >= target;   // ---2
   return num <= target;   // (注意,此时主函数中下标为idx-1)  ---3
   return num > target;	   // (注意,此时主函数中下标为idx-1)  ---4
}
🚆时间复杂度:O( n n n) 效率较低

🚓二分枚举

每次将区间折半,进行折半查找,这种方式又称作折半查找,时间复杂度为O( l o g 2 n log_2n log2n)
引入例题:

在这里插入图片描述

🦼二分枚举模板
bool isGreen(int x, int y) {  // 判断函数
    return x == y;
}

int binarySearch(int *arr, int arrSize, int x) {
    int l = -1, r = arrSize;         // (1) 注意,l和r的初始值都不在数组索引范围内
    int mid;
    while(r - l > 1) {               // (2) 当左右相差为1时,说明已经来到分界点
        mid = l + (r - l) / 2;       // (3) ⭐防溢出的保险写法
        if( isGreen(arr[mid], x) )   // (4) x是指绿色所代表的颜色
            r = mid;                 // (5) 如果mid所指地点为绿色,则mid-r都是绿色
        else
            l = mid;                 // (6) 如果mid所指地点为红色,则l-mid都是红色
    }
    return r;                        // (7) 返回下标最小的绿色元素
// 本模板最为灵活的地方在于其返回值:
    // 当要返回最小绿色时,return r
    // 当要返回最大红色时,return l
}
🚅迭代过程的实质以及其结束条件

迭代实质:红绿指针不断逼近红绿分界线的过程

结束条件:红绿指针指向红绿分界线。

初始化

红色游标初始值为:-1,绿色游标初始值为:n

如果使红色游标初始值为:0,绿色游标初始值为:n-1 当元素全红全绿的情况下违反了:

红色游标始终指向红色,绿色游标始终指向绿色

终点位置

⭐mid = ⌊ l + r 2 ⌋ \lfloor \frac{l+r}{2} \rfloor 2l+r

l的最小值是-1,r的最小值是1+2,所以mid = 0 // 极限情况,仅有一个元素时

r的最大值为n,l的最大值为r-2,所以mid = n-1 ----- 由此中点的位置 [ 0 , n ) [0, n) [0,n)


🚚二分查找数组模板

// 通过修改isGreen函数可解决绝大部分二分查找问题
/************** 二分查找 数组 模板 **************/
/*

  1)传参的数组满足:红红红红红红红红绿绿绿绿绿绿绿; 
  2)返回值:绿色区段的左边界; 
*/

int isGreen(int val, int x);

int binarySearch(int *arr, int arrSize, int x) {
    int l = -1, r = arrSize;
    int mid;
    while(l + 1 < r) {
        mid = l + (r - l) / 2;
        if( isGreen(arr[mid], x) )
            r = mid;
        else
            l = mid;
    }
    return r;
}
/************** 二分查找 数组 模板 **************/

🚲二分查找具体应用

🛰数组元素的精确查找

在这里插入图片描述

// 二分查找实例应用
int isGreen(int val, int x);
int binarySearch(int *arr, int arrSize, int x) {
    int l = -1, r = arrSize;
    int mid;
    while(l + 1 < r) {
        mid = l + (r - l) / 2;
        if( isGreen(arr[mid], x) )
            r = mid;
        else
            l = mid;
    }
    return r;
}
/************** 二分查找 数组 模板 **************/

int isGreen(int val, int x) {
    return val >= x;                       // (1)
}

int search(int* nums, int numsSize, int target){
    int r = binarySearch(nums, numsSize, target); // (2) 找到红绿分界处的靠右分界点
    if(r == numsSize || nums[r] != target)  // (3) 找不到或者全部小于target的两种特殊情况
        return -1;
    return r;                              // (4)
}

有序数组一般可以优先考虑 二分查找。

✈线性枚举 + 数据的精确查找

在这里插入图片描述

class Solution {
public:
    bool isGreen(int x, int target) {
        return x >= target;
    }

    int binarySearch(vector<int>arr, int target) {
        int len = arr.size();
        int left = -1;
        int right = len;        
        int mid;
        while(right-left > 1) {
            mid = left + (right - left) / 2;
            if(isGreen(arr[mid], target)) {
                right = mid;
            }else {
                left = mid;
            }
        }
        return right;
    }

    vector<int> twoSum(vector<int>& nums, int target) {
        int len = nums.size();
        int left = -1;
        int right = len;
        vector<int>ans;
        for(int i = 0; i < len; ++i) {  // 线性枚举ing
            ans.push_back(nums[i]);
            int diff = target - nums[i]; // 二分查找目标元素
            int right = binarySearch(nums, diff);  // 二分查找ing
            if(right == len || nums[right] != diff)   {  // 筛选出不合要求的下标
                ans.clear();  // 容器清空
                continue;
            }
            else {
                ans.push_back(nums[right]);
                break;
            }
        }
        return ans;
    }
};

// 时间复杂度:O(nlogn2)
// 注意:复杂度过高无法通过
🚤数组的模糊查找
  • 1.大于等于x的最小值

在这里插入图片描述

class Solution {
public:
    bool isGreen(int val, int target) {
        return val >= target;
    }

    int binarySearch(vector<int>& nums, int target) {
        int len = nums.size();
        int left = -1;
        int right = len;
        int mid;
        while(right - left > 1) {
            mid = left + (right - left) / 2;
            if(isGreen(nums[mid], target)) {
                right = mid;
            }else {
                left = mid;
            }
        }
        return right;
    }

    int searchInsert(vector<int>& nums, int target) {
        return binarySearch(nums, target);
    }
};
  • 大于x的最小值
    在这里插入图片描述

    class Solution {
    public:
        bool isGreen(char val, char target) {
            return val > target;
        }
    
        int binarySearch(vector<char> letters, char target) {
            int len = letters.size();
            int left = -1;
            int right = len;
            int mid;
            while(right - left > 1) {
                mid = left+(right-left)/2;
                if(isGreen(letters[mid], target)) {
                    right = mid;
                }else {
                    left = mid;
                }
            }
            return right;
        }
    
        char nextGreatestLetter(vector<char>& letters, char target) {
            int pos = binarySearch(letters, target);
            if(pos == letters.size())   return letters[0];
            return letters[pos];
        }
    };
    
  • 小于等于x的最大值

在这里插入图片描述

bool isGreen(int val, int target) {
    return val > target;
}

int binarySearch(vector<int> nums, int target) {
    int len = nums.size();
    int left = -1;
    int right = len;
    int mid;
    while(right - left > 1) {
		mid = left + (right - left) / 2;
        if(isGreen(nums[mid], target)) {
            right = mid;
        }else {
            left = mid;
        }
    }
    return right-1;
}

int getIndex(vector<int> nums, int target) {
	int pos = binarySearch(nums, target);   
    return pos;
}
  • 小于x的最大值
    在这里插入图片描述
bool isGreen(int val, int target) {
    return val >= target;
}

int binarySearch(vector<int> nums, int target) {
    int len = nums.size();
    int left = -1;
    int right = len;
    int mid;
    while(right - left > 1) {
		mid = left + (right - left) / 2;
        if(isGreen(nums[mid], target)) {
            right = mid;
        }else {
            left = mid;
        }
    }
    return right-1;
}

int getIndex(vector<int> nums, int target) {
	int pos = binarySearch(nums, target);   
    return pos;
}

总结:

在这里插入图片描述

🚁单调函数的查找

在这里插入图片描述

class Solution {
public:
    bool isGreen(int x, int target) {
        return (long long)x*x > target;  // 进行强制类型转化,防止数据溢出
    }

    int BinarySearch(int target) {  // 这里的二分查找:大于的最小值
        int left = 0;
        int right = target;
        int mid;
        while(right - left > 1) {
            mid = left + (right - left) / 2;
            if(isGreen(mid, target)) {
                right = mid;
            }else {
                left = mid;
            }
        }
        return right-1;  // 当开平方为整数时,right-1为开平方后的结果
        // 开平方位小数时,righ-1为取整后的结果
    }

    int mySqrt(int x) {
        if(x == 0 || x == 1)   return x;   // 1 and 0的平方是本身
        return BinarySearch(x);
    }
};

⛽二分枚举的通解:

  • 抽象出一个单调函数
  • 确定isGreen函数
  • 二分枚举求出红绿边界
  • 确定返回红色边界还是绿色边界

参考文章:

[1] 本文部分内容来自于 英雄哪里出来
一位非常优秀的程序员!B站指路:英雄哪里出来

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,下面是关于二分查找递归实验的小结二分查找是一种常用的算法,它通过将有序数组分成两部分,每次取中间值进行比较,以确定目标值在哪一部分。二分查找的时间复杂度为O(log n),比线性查找的O(n)要快得多。在实际应用中,二分查找被广泛应用于各种搜索场景,如查找有序数组中的元素、查找旋转有序数组中的元素等。 在实验中,我们通过递归的方式实现了二分查找算法。具体步骤如下: 1. 定义递归函数binary_search,传入参数arr、left、right和target,其中arr为有序数组,left和right表示当前查找区间的左右边界,target为目标值。 2. 在递归函数中,判断当前查找区间是否为空,如果是则返回-1,表示未找到目标值。 3. 取当前查找区间的中间位置mid,比较arr[mid]和target的大小关系,如果arr[mid]等于target,则返回mid,表示找到了目标值。 4. 如果arr[mid]大于target,则说明目标值在左半部分,递归调用binary_search函数,在左半部分查找目标值。 5. 如果arr[mid]小于target,则说明目标值在右半部分,递归调用binary_search函数,在右半部分查找目标值。 下面是二分查找递归实现的代码: ```c #include <stdio.h> int binary_search(int arr[], int left, int right, int target) { if (left > right) { return -1; } int mid = (left + right) / 2; if (arr[mid] == target) { return mid; } else if (arr[mid] > target) { return binary_search(arr, left, mid - 1, target); } else { return binary_search(arr, mid + 1, right, target); } } int main() { int arr[] = {1, 3, 5, 7, 9, 11, 13, 15, 17}; int n = sizeof(arr) / sizeof(arr[0]); int target = 9; int index = binary_search(arr, 0, n - 1, target); if (index == -1) { printf("Target not found!\n"); } else { printf("Target found at index %d.\n", index); } return 0; } ``` 在实验过程中,我们需要注意以下几点: 1. 二分查找要求数组是有序的,如果数组无序,需要先进行排序操作。 2. 在递归调用binary_search函数时,需要传入的left和right参数要根据当前的查找区间来确定,不能传入固定的值。 3. 在计算mid时,要注意防止整型溢出的问题,可以使用(left + right) / 2的方式计算,也可以使用left + (right - left) / 2的方式计算。 总之,二分查找是一种非常实用的算法,掌握了二分查找的实现方法,可以在实际编程中提高查找效率。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值