LeetCode 二分题库

wanger_xx

已于 2022-01-19 11:24:27 修改

阅读量136

点赞数

分类专栏： leetcode刷题手记文章标签： leetcode

于 2022-01-13 22:52:23 首次发布

本文链接：https://blog.csdn.net/qq_52138199/article/details/122479930

版权

leetcode刷题手记专栏收录该内容

18 篇文章 1 订阅

订阅专栏

lc.69 sqrt(x)

给你一个非负整数 x ，计算并返回 x 的算术平方根。
由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

不大于 x 的最大值

class Solution {
public:
    int mySqrt(int x) {
        if(x == 0) return 0 ;
        int l = 1 , r = x / 2 , mid ;
        while(l < r){
            mid = l + r + 1 >> 1;
            if((long long)mid * mid <= x)  l = mid ;
            else r = mid - 1 ;
        }
        return l;
    }
};

注意到，int == long int 2 * 10⁹ = 2¹⁵。long long 9 * 10¹⁸ = 2³¹。

        while(l < r){
            mid = l + r >> 1;
            if((long long)mid * mid > x)  r = mid ;
            else l = mid + 1 ;
        }

wrong answer ，求出来是大于 x 的最小值，与题意不符。返回值会多 1 。

如果不用 long long

int mySqrt(int x) 
    {
        if(x == 1)
            return 1;
        int min = 0;
        int max = x;
        while(max-min>1)
        {
            int m = (max+min)/2;
            if(x/m<m)
                max = m;
            else
                min = m;
        }
        return min;
    }

lc.349 数组的交集

哈希表 O(m+n)

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> us{nums1.begin(),nums1.end()};
        vector<int> ans;
        for(auto& i : nums2){
            if(us.find(i) != us.end()){
                us.erase(i);
                ans.emplace_back(i);
            }
        }
        return ans;
    }
};

emplace_back() 构造函数，push_back 需要将元素类型的对象传递给它们，然后这些对象被拷贝到容器中。当我们调用emplace成员函数时，会减少一次拷贝的过程，提升容器插入效率。

std::unordered_map插入、删除的性能会比std::map稍差一点，但是查找速度std::unordered_map和std::map的比例基本上是2:1。

find函数比count执行时间短。find(x)功能是在map中搜索键为x的元素，若找到则返回迭代器（位置），否则返回迭代器为map::end（即容器末尾元素）。值调用使用 iter->first/second 选择在于值在map的位置。

采用引用传递，不必建形参，快。

sort + 双指针 O(mlogm+nlogn)

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(), nums1.end());
        sort(nums2.begin(), nums2.end());
        int length1 = nums1.size(), length2 = nums2.size();
        int index1 = 0, index2 = 0;
        vector<int> intersection;
        while (index1 < length1 && index2 < length2) {
            int num1 = nums1[index1], num2 = nums2[index2];
            if (num1 == num2) {
                // 保证加入元素的唯一性
                if (!intersection.size() || num1 != intersection.back()) {
                    intersection.push_back(num1);
                }
                index1++;
                index2++;
            } else if (num1 < num2) {
                index1++;
            } else {
                index2++;
            }
        }
        return intersection;
    }
};

真就先 sort ，慢。

lc.367 有效完全平方数

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

long long

class Solution {
public:
    bool isPerfectSquare(int num) {
        long long int l = 1 , r = num;
        long long int mid ; 
        while(l < r){
            mid = l + r + 1 >> 1 ;
            if((long long) mid * mid <= num) l = mid ;
            else r = mid - 1 ;
        }
        if((long long)l * l == num) return true;
        else return false;
    }
};

lc.34 排序数组中查找元素第一和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。

得考虑一下数组空的情况。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> ans;
        if(!nums.empty()){
            int l = 0 , r = nums.size() - 1 ;
            while(l < r){
                int mid = l + r >> 1;
                if(nums[mid] >= target) r = mid;
                else l = mid + 1; 
            }
            if(nums[l] != target) ans.emplace_back(-1);
            else ans.emplace_back(l);
            l = 0 , r = nums.size() - 1 ;
            while(l < r){
                int mid = l + r + 1>> 1;
                if(nums[mid] <= target) l = mid;
                else r = mid - 1; 
            }
            if(nums[l] != target) ans.emplace_back(-1);
            else ans.emplace_back(l); 
        }
        else{
            ans.emplace_back(-1);
            ans.emplace_back(-1);
        }              
        return ans;
    }
};

lc.33 搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

找原数组的头

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int min = 1e4 , xbmin = 0 ;
        for(int i = 0 ; i < nums.size() ; i ++){
            if(nums[i] < min){
                min = nums[i];
                xbmin = i ;
            }
        }
        int l = 0 , r = xbmin - 1 ;
        while(l < r){
            int mid = l + r >> 1;
            if(nums[mid] >= target) r = mid;
            else l = mid + 1;
        }
        if(nums[l] == target) return l;
        l = xbmin , r = nums.size() - 1;
        while(l < r){
            int mid = l + r >> 1;
            if(nums[mid] >= target) r = mid;
            else l = mid + 1;
        }
        if(nums[l] == target) return l;
        return -1;
    }
};

lc.74 搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

连成一个整体一次二分

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m=matrix.size();
        int n=matrix[0].size();
        int size=m*n;
        int T=size-1;
        int H=0;
        while(H<T){
            int mid=(H+T)/2;
            int X=mid%n;
            int Y=mid/n;
            if(matrix[Y][X]<target){
                H=mid+1;
            }
            else if(matrix[Y][X]>target){
                T=mid-1;
            }
            else
                return true;
        }
        int X=H%n;
        int Y=H/n;
        if(matrix[Y][X]==target)
            return true;
        return false;
    }
};

lc.153 寻找旋转排序数组中的最小值

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：

若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]

注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。
给你一个元素值互不相同的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的最小元素。

找头

class Solution {
public:
    int findMin(vector<int>& nums) {
        for(int i = 0 ; i < nums.size() - 1 ; i ++){
            if(nums[i] >= nums[i + 1]) return nums[i + 1];
        }
        return nums[0];
    }
};

都没有用到二分。

二分

class Solution {
public:
    int findMin(vector<int>& nums) {
        int low = 0;
        int high = nums.size() - 1;
        while (low < high) {
            int pivot = low + (high - low) / 2;
            if (nums[pivot] < nums[high]) {
                high = pivot;
            }
            else {
                low = pivot + 1;
            }
        }
        return nums[low];
    }
};

lc.162 寻找峰值

峰值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。
你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

和 lc.153 一样，也可以用一次 O(n) 的遍历解决。不过二分理论上更快。

二分查找

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int l = 0 , r = nums.size() -1 ;
        while(l < r){
            int mid = l + r >> 1;
            if(nums[mid+1] < nums[mid]) r = mid;
            else l = mid + 1;
        }
        return l;
    }
};