Leetcode 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

第一次代码暴力破解

两个判断即可

判断目标和数组相对应下标相同

判断该数字是否在两个数的中间

class Solution {
    static int searchInsert(int[] nums, int target) {
        if (nums[0] > target)
            return 0;
        for (int i = 0; i < nums.length ; i++) {
            if (nums[i] == target)
                return i;
            if (i<nums.length-1)
            if (target > nums[i] && target < nums[i + 1])
                return i + 1;
        }
        return nums.length;
    }
}

另外解法使用二分查找

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

 

看了解题后才了解

为什么没有找到target返回left？？今天终于搞清楚了。

注意：以下讨论的是没有找到target

很容易想象，经过每次while循环，都会使得[left,right]的左闭右闭区间中的元素减少。

那就有一个问题，减少到最后会是什么情况？

那就是进入最后一次while循环前，[left,right]的左闭右闭区间中只有一个或者两个元素，即

left和right的位置有且仅有2种情况

• left = right

  或

• left = right -1

为什么？ 举几个特例

• 数组有一个元素，那么left = right，还需要最后一次while循环

• 数组有两个元素，那么left = right -1, 分两种情况，需要一或两次while循环

  1. 比如数组 [1,3] ,target=0，此时left = right -1, 然后还需最后一次while

  2. 比如数组 [1,3] ,target=2，一次while循环后，left = right =1，并且变成了一个元素的情况，还要一次while，一共是2个while

• 数组有三个，四个元素等等，都以此类推，最后都会变成以上的情况

综上，数组最后会变为一个元素，或者两个元素中的情况1

以上就解释清楚了，在进入最后一次while循环前，数组会变为一个或两个元素。

以下是一个元素和两个元素(情况1)的代码注释

数组只有一个元素，假设nums=[1]，left = right

	  left = rigth=0//初始化
      while(left < =right){         //进入最后一次循环
           int mid = (left + right) / 2;         //mid =0, 此时`left = mid = right=0`
           if (target == nums[mid]) {          
               return mid;        //若找到，直接返回mid，下面两个else是没有找到target的情况
           } else if (target < nums[mid]) {   
               right = mid - 1;  //此时数组中仅剩的最后一个数比target大，执行right=mid-1=-1, 而left=0正是要插入的位置
           } else {
               left = mid + 1;    //此时数组中仅剩的最后一个数比target小，执行left =mid+1=1,  left=1正是要插入的位置
           }
       }//循环结束

2. 数组有两个元素(情况1)，假设nums=[1，3]，target =0, left = right -1

	  left = 0, rigth=1;//初始化
      while(left < =right){         //进入最后一次循环
           int mid = (left + right) / 2;         //mid =0, 此时`left = mid =0 , right =1 `
           if (target == nums[mid]) {          
               return mid;        //若找到，直接返回mid，下面两个else是没有找到target的情况
           } else if (target < nums[mid]) {   
               right = mid - 1;  //此时target < nums[0]，执行right=mid-1=-1, 而left=0正是要插入的位置
           } else {
               left = mid + 1;    //此时target > nums[0]，执行left =mid+1=1,  left=1正是要插入的位置
           }
       }//循环结束

总结：

1个元素的情况很简单，随便举个特例就行，如[1],target=0或3。

2个元素中的情况1也可以举个特例，如[1, 3],target=0。

都能发现，没有找到target返回left即可。