2020_12_19 LeetCode刷题

最新推荐文章于 2024-06-14 16:24:32 发布

Ls_attack

最新推荐文章于 2024-06-14 16:24:32 发布

阅读量104

点赞数

分类专栏： LeetCode题目

本文链接：https://blog.csdn.net/Ls_attack/article/details/111407338

版权

LeetCode题目专栏收录该内容

21 篇文章 0 订阅

订阅专栏

2020_12_19 LeetCode刷题

今日刷题三道，都是二分法有关题目，以下是回顾总结。

167. 两数之和 II - 输入有序数组
从头开始遍历数组，之后以当前位置+1为起点，数组最后一个元素的位置为终点，进行二分查找，二分查找返回的是数组下标，为-1则答案不正确。得出答案，返回结果即可。

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> ans;
        int len1 = numbers.size();
        for(int i = 0; i < len1 - 1; i++) {
            //if(target-numbers[i] > 0) {
                int z = binary(i+1,len1-1,target-numbers[i],numbers);
                if(z!=-1) {
                    ans.push_back(i+1);
                    ans.push_back(z+1);
                    break;
                }
            //}    
        }
        return ans;
    }
    int binary(int start,int end1,int target,vector<int>& nums) {
        int ans = -1, mid = 0;
        while(start < end1) {
            mid = (start + end1) / 2;
            if(nums[mid] == target) {
                ans = mid;
                break;
            }
            if(nums[mid] > target) {
                end1 = mid - 1;
            }
            if(nums[mid] < target) {
                start = mid + 1;
            }
        }
        if(start == end1) {
            if(nums[start] == target)
                ans = start;
        }
        return ans;
    }
};

278. 第一个错误的版本
二分搜索题。前面有若干个为false的错误版本，之后有若干个true的正确版本，查找第一个为true的正确版本，二分法查找答案即可，中间的数值可能超出int的数据范围，使用long long进行中间变量的存储。

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

class Solution {
public:
    int firstBadVersion(int n) {
        int ans = binary(1,n);
        return ans;
    }
    int binary(long long start,long long end1) {
        long long ans = 0;
        long long mid = 0;
        while(start < end1) {
            mid = (start + end1) / 2;
            if(isBadVersion(mid) == true) {
                if(isBadVersion(mid - 1) == false) {
                    ans = mid;
                    break;
                } else
                    end1 = mid - 1;
            }
            if(isBadVersion(mid) == false)
                start = mid + 1;
        }
        if(start == end1) {
            if(isBadVersion(start) == true)
                ans = start;
            else
                ans = start - 1;
        }
        return ans;
    }
};

350. 两个数组的交集 II
二分查找法。遍历个数少的数组，在元素多的数组内使用二分法进行查找，这里使用find函数进行查找，对于找到的元素，使用erase函数进行元素的删除，避免重复查找。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans;
        int len1 = nums1.size(), len2 = nums2.size();
        if(len1 < len2) {
            for(int i = 0 ;i < len1 ; i++) {
                vector<int>::iterator result = find(nums2.begin(),nums2.end(),nums1[i]);
                if( result != nums2.end()) {
                    nums2.erase(result);
                    ans.push_back(nums1[i]);
                }
            }
        } else {
            for(int i = 0 ;i < len2 ; i++) {
                vector<int>::iterator result = find(nums1.begin(),nums1.end(),nums2[i]);
                if(result != nums1.end()) {
                    nums1.erase(result);
                    ans.push_back(nums2[i]);
                }
            }
        }
        return ans;
    }
};