Leetcode刷题笔记（C++）——二分查找

最新推荐文章于 2021-08-19 11:04:15 发布

L的知识库

最新推荐文章于 2021-08-19 11:04:15 发布

阅读量409

点赞数

分类专栏： Leetcode刷题笔记文章标签：数据结构 leetcode c++ 算法

本文链接：https://blog.csdn.net/weixin_43273742/article/details/106871685

版权

这篇博客整理了使用C++在LeetCode上刷题时关于二分查找算法的应用，包括寻找两个正序数组的中位数、搜索旋转排序数组、在排序数组中查找元素的位置等题目，详细介绍了每个问题的解决方案和思路。

摘要由CSDN通过智能技术生成

Leetcode刷题笔记（C++）——二分查找

整理一下刷题过程中的思路，在这里进行一下总结与分享。
github地址：https://github.com/lvjian0706/Leetcode-solutions
github项目是刚刚新建的，陆续会将整理的代码以及思路上传上去，代码是基于C++与python的。同时会将基础的排序算法等也一并进行整理上传。

4. 寻找两个正序数组的中位数

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))
你可以假设 nums1 和 nums2 不会同时为空。

示例 1:
nums1 = [1, 3]
nums2 = [2]
则中位数是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]
则中位数是 (2 + 3)/2 = 2.5

class Solution {
   
public:
        /*
        寻找两个数组第k小的元素
        1. 当nums1为空时，返回nums2中第k小的元素；当nums2为空时，返回nums1中第k小的元素；
        2. 当k==1时，nums1[0]和nums2[0]中的最小值为返回值；
        3.1 如果nums1[k/2-1]<nums2[k/2-1]，说明nums1[0:k/2-1]中不可能存在中位数， 更新nums1=nums1[k/2:]； 同时更新k-=2/k；反之亦然；
        3.2 如果当前nums1的长度小于k/2-1，则将3.1中nums1[k/2-1]替换为nums[len1-1]，保证数组不越界，更新nums1=nums1[len:](空数组)，同时更新k-=此时nums1的长度;
        */
    double findKth(vector<int>& nums1, vector<int>& nums2, int len1, int len2, int k){
   
        int left1 = 0, left2 = 0;
        while(true){
   
            if(left1==len1){
   
                return nums2[left2+k-1];
            }
            if(left2==len2){
   
                return nums1[left1+k-1];
            }
            if(k==1){
   
                return min(nums1[left1], nums2[left2]);
            }
            int new_left1 = min(left1+k/2-1, len1-1);
            int new_left2 = min(left2+k/2-1, len2-1);
            if(nums1[new_left1] <= nums2[new_left2]){
   
                k -= new_left1 - left1 + 1;
                left1 = new_left1 + 1;
            }
            else{
   
                k -= new_left2 - left2 + 1;
                left2 = new_left2 + 1;
            }
        }
    }
        /*
        寻找两个正序数组的中位数，即找到两个数组合并后第(nums1.size()+nums2.size())/2小的元素
        */
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
   
        /*
        k = (nums1.size()+nums2.size())/2;
        当nums1.size()+nums2.size()为奇数时，返回第k+1小的元素；
        当nums1.size()+nums2.size()为偶数时，返回第k小的元素和第k+1小的元素均值；
        */
        int len1 = nums1.size();
        int len2 = nums2.size();
        int k = (len1+len2)/2;
        if((len1+len2)%2==0) return (findKth(nums1, nums2, len1, len2, k) + findKth(nums1, nums2, len1, len2, k+1)) / 2;
        else return findKth(nums1, nums2, len1, len2, k+1);
    }
};

33. 搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。

示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

class Solution {
   
public:
    /*
    有序数组查找目标值：二分查找
    1. 需要将nums[mid]与nums[left]进行比较，判断旋转区间
    2. 根据旋转区间范围以及target与nums[mid]的比较共同查找目标值
    */
    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) return mid;
            /*
            只有一个元素且不等于target时，返回-1；
            */
            else if(left==right){
   
                return -1;
            }
            /*
            nums[mid]大于nums[left]时，数组最小值在nums[mid]右边：
            1. nums[mid]大于target时，需要根据target与nums[left]大小判断target所在区间
            1.1 target大于nums[left]时，target位于nums[left:mid-1]
            1.2 target小于nums[left]时，target位于nums[mid+1：]
            2. nums[mid]小于target时，target位于nums[mid+1：]
            */
            if(nums[mid]>nums[left]){
   
                if(nums[mid]>target){
   
                    if(target>nums[left]) right = mid-1;
                    else if(target<nums[left]) left = mid+1;
                    else return left;
                }
                else if(nums[mid]<target){
   
                    left = mid+1;
                }
            }
            /*
            nums[mid]小于nums[left]时，数组最小值在nums[mid]左边：
            1. nums[mid]小于target时，需要根据target与nums[left]大小判断target所在区间
            1.1 target大于nums[left]时，target位于nums[left:mid-1]
            1.2 target小于nums[left]时，target位于nums[mid+1：]
            2. nums[mid]大于target时，target位于nums[left:mid-1]
            */
            else if(nums[mid]<nums[left]){
   
                if(nums[mid]<target){
   
                    if(target>nums[left]) right = mid-1;
                    else if(target<nums