【LeetCode-java】001-300复习【04】二分查找专题

最新推荐文章于 2024-05-20 21:56:33 发布

招财猫qwq

最新推荐文章于 2024-05-20 21:56:33 发布

阅读量119

点赞数

分类专栏： LeetCode 文章标签： leetcode 二分法

本文链接：https://blog.csdn.net/weixin_42711949/article/details/107456227

版权

LeetCode 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

中等两数相除 Divide Two Integers
20.07.15
思路：由大到小查找，每次除以2.

class Solution {
    public int divide(int dividend, int divisor) {
        if(dividend == 0) return 0;
        if(dividend == Integer.MAX_VALUE && divisor == -1) return Integer.MAX_VALUE;
        boolean negative;
        negative = (dividend^divisor) < 0;
        long t = Math.abs((long) dividend);
        long d = Math.abs((long) divisor);
        int result = 0;
        for(int i=31;i>=0;i--){
            if((t>>i)>=d){
                result += 1<<i;
                t -= d<<i;
            }
        }
        return negative ? -result:result;
    }
}

中等搜索旋转排序数组 Search in Rotated Sorted Array
20.07.15
思路：二分，其中一个必有序，另一无序，然后依次下去。

class Solution {
    public int search(int[] nums, int target) {
        int len = nums.length;
        int left = 0;
        int right = len - 1;
        while(left<=right){
            int mid = left + (right-left)/2;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid]<nums[right]){
                if(nums[mid] < target && target <= nums[right]){
                    left = mid + 1;
                }else{
                    right = mid - 1;
                }
            }else{
                if(nums[left] <=  target && target <= nums[mid]){
                    right = mid - 1;
                }else{
                    left = mid + 1;
                }
            }
        }
        return -1;
    }
}

中等在排序数组中查找元素 Find First and Last Position of Element in Sorted Array
20.07.15
思路：一个查左边一个查右边。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] ans = new int[2];
        int len = nums.length;
        if(len == 0) return ans;
        int left = 0;
        int right = len-1;

        while(left<right){
            int mid = left + (right-left)/2;
            if(nums[mid] >= target) right = mid;
            else left = mid + 1;
        }
        if(nums[left] != target) return ans;
        ans[0] = left;
        right = len;

        while(left<right){
            int mid = left + (right-left)/2;
            if(nums[mid] <= target) left = mid+1;
            else right = mid;
        }
        ans[1] = left-1;
        return ans;
    }
}

简单搜索插入位置 Search Insert Position
20.07.16
思路：二分查找。模板就不要改了。

class Solution {
    public int searchInsert(int[] nums, int target) {
        int len = nums.length;
        int left = 0;
        int right = len - 1;
        
        while(left<=right){
            int mid = left + (right-left)/2;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid]<target){
                left = mid + 1;
            }else{
                right = mid - 1;//要-1不然会超时
            }  
        }
        return left;
    }
}

中等 Pow(x,n) Pow(x,n)
20.07.16
思路：二分查找减少。负数的返回倒数。

class Solution {
    public double myPow(double x, int n) {
        double ans = 1.0;
        for(int i = n; i != 0 ;i/=2){
            if(i%2 != 0){
                ans *= x;
            }
            x *= x;
        }
        return n<0 ? 1/ans: ans;
    }
}

简单 x的平方根 Sqrtx
20.07.16
思路：二分查找

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

中等搜索旋转排序数组II Search in Rotated Sorted Array II
20.07.16
思路：33题加去重。

class Solution {
    public boolean search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while(left <= right){
            while(left < right && nums[left] == nums[left+1]) left++;
            while(left < right && nums[right] == nums[right-1]) right--;//3Sum的去重
            int mid = left + (right-left)/2;
            if(nums[mid] == target){
                return true;
            }if(nums[mid] >= nums[left]){
                if(target < nums[mid] && target>=nums[left]) right = mid - 1;
                else left = mid + 1;
            }else{
                if(target > nums[mid] && target<=nums[right]) left = mid + 1;
                else right = mid - 1;
            }
        }
        return false;
    }
}

中等寻找旋转排序数组的最小值 Find Minimum in Rotated Sorted Array
20.07.16
思路：思路不难，边界条件太烦了。

class Solution {
    public int findMin(int[] nums) {


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

    }
}

中等寻找峰值元素 Find Peak Element
20.07.16
思路：二分，大的部分一定有峰值。

class Solution {
    public int findPeakElement(int[] nums) {
        int left = 0, right = nums.length - 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (nums[mid] > nums[mid + 1])
                right = mid;
            else
                left = mid + 1;
        }
        return left;

    }
}

简单第一个错误的版本 First Bad Version
20.07.16
思路：emm题目说的也不太清楚。

public class Solution extends VersionControl {
    public int firstBadVersion(int n) {
        int left = 1;
        int right = n;
        while(left<right){
            int mid = left + (right-left)/2;
            if(isBadVersion(mid)){
                right = mid;
            }else{
                left = mid+1;
            }
        }
        return right;
    }
}

中等 H指数II H-Index II
20.07.16
思路：二分查就完事。

class Solution {
    public int hIndex(int[] citations) {
        if(citations == null || citations.length == 0) return 0;
        int ans = 0;
        int left = 0;
        int right = citations.length-1;
        while(left<=right){
            int mid = left + (right-left)/2;
            int gap = citations.length - mid;
            if(citations[mid] >= gap){
                ans = gap;
                right = mid-1;
            }else{
                left = mid+1;
            }
        }
        return ans;
        // int ans = 0;
        //for(int i=0;i<citations.length;i++){
        //     if(citations[i] >= citations.length-citations[i]){
        //         ans = citations[i];break;
        //     }
        // }
        //return ans;
    }
}