leetcode————二分查找刷题合集

二分查找简介

推荐刷题顺序
704. 二分查找
35. 搜索插入位置
69. x 的平方根
35. 搜索插入位置
367. 有效的完全平方数
34. 在排序数组中查找元素的第一个和最后一个位置

二分中的
对待二分查找的时候 所遇到的方法的不同
即 查找时候对应的边界问题

l<r
	最大的区别就是 r=midel
				   l=midel+1;
l<=r
	r=midel+1;
	l=midel-1;

对应的题目连接704. 二分查找

  给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，
写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

基本的二分查找的模板

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

对应的题目连接35. 搜索插入位置

题目描述

	给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。
如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

class Solution {
    public int searchInsert(int[] nums, int target) {
            if(target>nums[nums.length-1])
                return nums.length;
            
            int l=0;
            int r=nums.length-1;

            while( l<r){
                int mid=l+(r-l)/2;
                if(nums[mid] >= target) r =mid;
                else
                    l =mid+1;
            }

            return l;
    }
}

此题中的 while(left<=right)
此处的写法就是保证r=mid-1成立

对应的题目连接69. x 的平方根

  给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

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

相似题目，相似的类型

对应的题目367. 有效的完全平方数

给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

class Solution {
    public boolean isPerfectSquare(int num) {
        int l = 0, r = num, ans = -1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if ((long) mid * mid <= num) {
                ans = mid;
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return ans*ans==num?true:false;
    }
}

对应的题目35. 搜索插入位置

  给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

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

贴一个大神的写法

对应的题目34. 在排序数组中查找元素的第一个和最后一个位置

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

二分查找 最主要的就是分清楚 对应的r更新第一个值 l更新第二个值

class Solution {
    public int[] searchRange(int[] nums, int target) {
         int[] arr = {-1,-1};
         if(nums == null || nums.length ==0){
             return arr;
         }
         arr[0]=Findfirst(nums, target);
         arr[1]=Findlast(nums, target);
         return arr;
    }
    
    public int Findfirst(int [] nums, int target){
        int l=0;
        int r=nums.length-1;
        int ans =-1;
        int mid=0;
        while(l<=r){
            mid = l+((r-l)>>1);
            if(nums[mid] > target){
                r=mid-1;
            }else if(nums[mid] <target){
                l=mid+1;
            }else{
                ans=mid;
                r=mid-1;
            }
        }
        return ans;
    }

        public int Findlast(int [] nums, int target){
        int l=0;
        int r=nums.length-1;
        int ans =-1;
        int mid=0;
        while(l<=r){
           mid = l+((r-l)>>1);
            if(nums[mid] >target){
                r=mid-1;
            }else if(nums[mid] < target){
                l=mid+1;
            }else{
                ans=mid;
                l=mid+1;
            }
        }
        return ans;
    }
}