LeetCode--Java实现704.二分查找、278.第一个错误的版本、35.搜索插入位置

学习背景

本文主要介绍如何通过Java实现LeetCode官方提供的以下数据结构与算法题目：

• 704.二分查找
• 278.第一个错误的版本
• 35.搜索插入位置

704.二分查找

题目分析

原题：

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

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

解题思路

• 数据结构与算法：数组 + 二分查找
• 实现思路：设定左右指针，找出中间位置，并判断该位置值是否等于 target
  nums[mid] == target 则返回该位置下标
  nums[mid] > target 则右侧指针移到中间
  nums[mid] < target 则左侧指针移到中间
• 时间复杂度：O(logN)对数复杂度

代码实现

具体代码：

/**
 * LeetCode：704.二分查找
 **/
public class LeetCode704 {
    public static void main(String[] args) {
        int[] nums = {-1,0,3,5,9,12};
        int target = 9;
//        int[] nums = {-1,0,3,5,9,12};
//        int target = 2;
        System.out.println(search(nums,target));;
    }

    /**
     * 数据结构与算法：数组 + 二分查找
     * 实现思路：设定左右指针，找出中间位置，并判断该位置值是否等于 target
     * nums[mid] == target 则返回该位置下标
     * nums[mid] > target 则右侧指针移到中间
     * nums[mid] < target 则左侧指针移到中间
     * 时间复杂度：O(logN) 对数复杂度
     * @param nums
     * @param target
     * @return
     */
    public static int search(int[] nums,int target){
        int left = 0,right = nums.length -1;
        while (left <= right){//循环
            int mid =left + (right - left)/2; //加上left指针，目的在于确保mid指针不会出现在left指针之前
            if (nums[mid] == target){
                return mid;
            }else if (nums[mid] > target){
                right = mid - 1; //mid - 1原因在于mid不是目标值，可直接剔除掉即取它的前一个给right指针
            }else{
                left = mid + 1; //mid + 1原因在于mid不是目标值，可直接剔除掉即取它的后一个给left指针
            }
        }
        return -1;
    }
}

输出结果：

4

278.第一个错误的版本

题目分析

原题：

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例 1：

输入：n = 5, bad = 4
输出：4
解释：
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。

示例2：

输入：n = 1, bad = 1
输出：1

提示：

1 <= bad <= n <= 231 - 1

解题思路

• 数据结构与算法：二分查找
• 实现思路：设定左右边界版本号，找出中间版本号，并判断该版本号是否是正确版本号
  isBadVersion(mid) == true，则将right右边界移到mid中间
  isBadVersion(mid) == false，则将left边界移到mid中间往后一个位置
• 时间复杂度：O(logN)对数复杂度

代码实现

/**
 * LeetCode：278.第一个错误的版本
 **/
public class LeetCode278 {
    private static int count = 0;  //调用了API接口的次数统计
    public static void main(String[] args) {
//        int n = 5;
        int n = (1 << 31) - 1; //即 2的31 -1，位运算中有个口诀叫：左移n位表示乘以2的n次方，右移n位，则表示除以2的n次方
        System.out.println(firstBadVersion(n));
        System.out.println("调用API接口次数：" + count);
    }

    public static int firstBadVersion(int n) {
        int left = 1,right = n; //定义左、右边界
        while (left < right){//循环
            //int mid = left + (right - left) / 2; //取整的效率不比位运算效率高
            int mid = left + ((right - left) >> 1); //计算中间位置，加left目的是确保mid指针不会出现在left指针之前
            if(isBadVersion(mid)){//如果中间位置已经问题版本了，那表明第一个坏的版本肯定在中间位置之前即[left,mid]范围
                right  = mid; //将right右边界移到mid中间
            }else{//如果中间位置还是正常版本，那表明第一个坏的版本肯定在中间位置之后即[mid + 1,right]范围
                left = mid + 1; //将left边界移到mid中间往后一个位置
            }
        }
        return left; //通过while循环后，此时left和right边界已经是同一个版本了，此时该版本就是第一个问题版本
    }

    /**
     * 模拟问题版本号的API
     */
    public static boolean isBadVersion(int mid){
        count++;
        int randomNum = (int)(Math.random() * 100) + 1;//取1~100的随机整数，其中Math.random()是[0.0-1.0)之间的double数
        if (0 == (mid % randomNum)){//这里假设中间版本对随机整数求余为0，则返回true，表示该版本的junit单元测试有问题即该版本号是问题版本号
            return true;
        }else{//否则说明该该版本号是正常版本号
            return false;
        }
    }
}

35.搜索插入位置

题目分析

原题：

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n)的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

示例 4:

输入: nums = [1,3,5,6], target = 0
输出: 0

示例 5:

输入: nums = [1], target = 0
输出: 0

提示:

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 为无重复元素的升序排列数组
-104 <= target <= 104

解题思路

• 数据结构与算法：二分查找
• 实现思路：定义left左下标、right右下标以及目标元素要存储的元素下标ans，计算中间位置mid
  当nums[mid] >= target，设定ans = mid以及将right右下标向中间mid - 1位置移动
  否则nums[mid] < target，将left左下标向中间mid + 1位置移动
• 时间复杂度：O(logN)对数复杂度

代码实现

/**
 * LeetCode：35. 搜索插入位置
 **/
public class LeetCode35 {
    public static void main(String[] args) {
        int[] nums = {1,3,5,6}; int target = 5;
//        int[] nums = {1,3,5,6}; int target = 2;
//        int[] nums = {1,3,5,6}; int target = 7;
//        int[] nums = {1,3,5,6}; int target = 0;
//        int[] nums = {1}; int target = 0;
        System.out.println(searchInsert(nums,target));
    }

    public static int searchInsert(int[] nums,int target){
        int n = nums.length;
        int left = 0; //左下标
        int right = n -1; //右下标
        int ans = n; //假设该位置是要插入元素的下标位置
        while (left <= right){//循环
            //int mid =left + (right - left) / 2; //取整的效率不比位运算高，位运算中有个口诀叫：左移n位表示乘以2的n次方，右移n位，则表示除以2的n次方
            int mid =left + ((right - left) >> 1); //中间元素下标，计算时加上left指针，目的在于确保mid指针不会出现在left指针之前
            if (nums[mid] >= target){//说明目标元素插入下标位置在[left,mid]范围
                ans = mid; //假设中间元素的下标刚好是要插入元素的下标位置
                right = mid - 1; //将右下标，向中间移动，mid - 1原因在于mid不是目标位置，可直接剔除掉即取它的前一个给right下标
            }else{
                left = mid + 1; //将左下标，向中间移动，mid + 1原因在于mid不是目标位置，可直接剔除掉即取它的后一个给left下标
            }
        }
        return ans; //循环执行完后，该值即为目标元素要插入的下标位置
    }