代码随想录leetcode刷题Day01-二分查找

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

class Solution {
    public int search(int[] nums, int target) {
        //如果明显不存在，则先判断，避免不必要的循环
        if (nums[0] > target || nums[nums.length - 1] < target) {
            return -1;
        }
        int head = 0;
        int end = nums.length - 1;
        int middle;

        while (head <= end) {
            middle = head + ((end - head) >> 1);//右移一位，相当于除2
            if (nums[middle] == target) {
                return middle;
            } else if (nums[middle] < target) {
                head = middle + 1;
            } else if (nums[middle] > target) {
                end = middle - 1;
            }
        }
        return -1;
    }
}

•  给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。 如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 你可以假设数组中无重复元素。

class Solution1 {
    public int searchInsert(int[] nums, int target) {
        int head = 0;
        int end = nums.length - 1;
        int middle;

        while (head <= end) {
            middle = head + (end - head) / 2;
            if (target == nums[middle]) {
                return middle;
            } else if (target > nums[middle]) {
                head = middle + 1;
            } else if (target < nums[middle]) {
                end = middle - 1;
            }
        }
        //如果没有找到，就将此元素插入到end + 1或head位置即可
        return end + 1;//return head;
    }
}

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

class Solution2 {
    public int mySqrt(int x) {
        if (x == 0) {
            return 0;
        }
        if (x == 1) {
            return 1;
        }
        int head = 1;
        int end = x / 2;
        int middle;
        while (head <= end) {
            middle = head + (end - head) / 2;
            if (middle == x / middle) { //使用除法防止int溢出
                return middle;
            } else if (middle < x / middle) {
                head = middle + 1;
            } else if (middle > x / middle) {
                end = middle - 1;
            }
        }
        //只保留整数部分，返回的是head前数
        return head - 1;
    }
}

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

class Solution3 {
    public boolean isPerfectSquare(int num) {
        if (num == 1) {
            return true;
        }
        int head = 1;
        int end = num / 2;
        int middle;
        long temp;
        while (head <= end) {
            middle = head + (end - head) / 2;
            //此处不能使用出发，因为会损失小数
            //使用乘法防止溢出，就提前转换为long类型
            temp = ((long) middle * middle);
            if (temp == num) {
                return true;
            } else if (temp < num) {
                head = middle + 1;
            } else if (temp > num) {
                end = middle - 1;
            }
        }
        return false;
    }
}

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

//先暴力遍历试试
class Solution4 {
    public int[] searchRange(int[] nums, int target) {
        int[] arr = new int[]{-1, -1};
        if (nums.length == 0) {
            return arr;
        }
        boolean isFlag = false;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                if (!isFlag) {
                    arr[0] = i;
                    arr[1] = i;
                    isFlag = true;
                } else {
                    arr[1] = i;
                }
            }
        }
        return arr;
    }
}

//二分法查找
class Solution5 {
    public int[] searchRange(int[] nums, int target) {
        int startIndex = searchStart(nums, target);
        int endIndex = searchEnd(nums, target);

        return new int[]{startIndex, endIndex};
    }

    private int searchStart(int[] nums, int target){

        int head = 0;
        int end = nums.length - 1;
        int middle;
        while(head <= end){
            middle = head + (end - head) / 2;
            if(nums[middle] == target){
                //虽然找到，但middle为首位或不是第一个target
                if(middle == 0 || nums[middle - 1] != nums[middle]){
                    return middle;
                }else{
                    end = middle - 1;
                }
            }else if(nums[middle] < target){
                head = middle + 1;
            }else{
                end = middle - 1;
            }
        }
        return -1;
    }

    private int searchEnd(int[] nums, int target){

        int head = 0;
        int end = nums.length - 1;
        int middle;
        while(head <= end){
            middle = head + (end - head) / 2;
            if(nums[middle] == target){
                if(middle == nums.length-1 || nums[middle] != nums[middle+1]){
                    return middle;
                }else{
                    head = middle + 1;
                }
            }else if(nums[middle] < target){
                head = middle + 1;
            }else{
                end = middle - 1;
            }
        }
        return -1;
    }