上好的刷题Day01

【题目1】

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

这道题目的前提是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件，当大家看到题目描述满足如上条件的时候，可要想一想是不是可以用二分法了。

二分查找涉及的很多的边界条件，逻辑比较简单，但就是写不好。例如到底是 while(left < right) 还是 while(left <= right)，到底是right = middle呢，还是要right = middle - 1呢？

大家写二分法经常写乱，主要是因为对区间的定义没有想清楚，区间的定义就是不变量。要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。

写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。

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

【题目2】

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

思路：与上面一致，返回的时候如果没找到则默认返回right后的位置进行插入就行

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

【题目3】

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。设计并实现时间复杂度为 O(log n) 的算法。

思路：一边一边的寻找边界，利用二分搜索方法。先找右边界，再找左边界。

【右边界】

• 中值大于目标值：中值右边的都不需要

• 中值小于目标值：中值左边的都不需要

• 中值等于目标值：因为找的是右边界，所以中值左边的都不要

【两个指针落点】

右边界存在（在数组中）：right(右边界) left

右边界不在（target不在数组中）：

•         右边界超过了数组最大：right() left(越界了)

•         右边界在数组两个数之中：二分搜索的找不到情况 right (右边界) left 

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int leftBorder = getLeftBrode(nums,target);
        int rightBorder = getRightBrode(nums,target);
        if(leftBorder ==-2 || rightBorder == -2)
            return new int[]{-1,-1};
        if(rightBorder-leftBorder >1)
            return new int[]{leftBorder+1,rightBorder-1};
        return new int[]{-1,-1};


    }
    public int getRightBrode(int[] nums, int target){
        int left = 0;
        int right = nums.length-1;
        int mid;
        int returnValue = -2;
        while(left <= right){
            mid = (left+right) / 2;
            if(nums[mid]>target)
                right = mid -1;
            else{
                left = mid +1;
                returnValue = left; //记录出现下标
            }
        }
        return returnValue;
    }
    public int getLeftBrode(int[] nums, int target){
        int left = 0;
        int right = nums.length-1;
        int mid;
        int returnValue = -2;
        while(left <= right){
            mid = (left+right) / 2;
            if(nums[mid]>=target){
                right = mid -1;
                returnValue = right; //记录出现下标 
            }else{
                left = mid +1;
            }
        }
        return returnValue;
    }
}

//理解
class Solution {
    public int[] searchRange(int[] nums, int target) {
       if(nums.length == 0)
            return new int[]{-1,-1};
        int rb = right(nums,target);
        int lb = left(nums,target);
        return new int[]{lb,rb}; 
    }
    public int right(int[] nums,int target){
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = (left+right) / 2;
            if(nums[mid] == target)
                left = mid + 1;
            else if(nums[mid] > target)
                right = mid - 1;
            else
                left = mid + 1;
        }
        if(right>=0&&right<=nums.length-1 && nums[right] == target)
            return right;
        else
            return -1;
    }
    public int left(int[] nums,int target){
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = (left+right) / 2;
            if(nums[mid] == target)
                right = mid - 1;
            else if(nums[mid] > target)
                right = mid - 1;
            else
                left = mid + 1;
        }
        if(left >=0&&left<=nums.length-1 &&nums[left] == target)
            return left;
        else
            return -1;
    }
}

 

【题目4】

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

思路：二分查找

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

【题目5】

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

思路：二分时间不够，t分

class Solution {
public boolean isPerfectSquare(int num) {
        int low = 1;
        int high = num;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            // int product = mid * mid;   越界
            int t = num / mid;
            if (t == mid) {
                if (num%mid == 0) return true;
                low = mid + 1;
            } else if (t < mid) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        return false;
    }
}

【补充】最重要的left 和 right两个指针搜索到最后会落在什么地方，最后跳出while循环的时候一定是 

找不到时候  right （中间就是需要找到） left 

能找到时候 mid 返回了