代码随想录算法训练营Day1 | 704.二分查找 35.搜索插入位置 34.在排序数组中查找元素的第一个和最后一个位置 27.移除元素

704. 二分查找

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length;

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

35. 搜索插入位置

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length;

        while (left < right) {
            int mid = left + (right - left)/2;

            if (target == nums[mid]) {
                return mid;
            }else if (target < nums[mid]){
                right = mid;
            }else if (target > nums[mid]) {
                left = mid + 1;
            }
        }
        // 目标值在数组所有元素之前 [0,0)
        // 目标值插入数组中的位置 [left, right) ，return right 即可
        // 目标值在数组所有元素之后的情况 [left, right)，因为是右开区间，所以 return right
        return right;
    }
}

同样也是二分查找的思路，不过最后插入的位置需要注意一下

其实left或者right都可以，因为最后跳出循环的时候left是等于right的。

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

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int index = binarySearch(nums, target);
        if (index == -1) {
            return new int[]{-1, -1};
        }

        int left = index;
        int right = index;
        while (left-1 >= 0 && nums[left-1] == target) {
            left--;
        }
        while (right+1 < nums.length && nums[right+1] == target) {
            right++;
        }
        return new int[]{left, right};
    }

    public int binarySearch(int[] nums, int target) {
        int left = 0;
        int right = nums.length;

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

本题的特点是给定的数组中会有连续相同的多个值。

首先，把二分查找写成一个独立的function，用于找出数组中某个等同于target的值。

然后，在这个值的基础上分别向左和向右one by one的搜索数组中等同于target的值，扩大范围。

27. 移除元素

class Solution {
    public int removeElement(int[] nums, int val) {
        int size = nums.length;
        for (int i = 0; i < size; i++) {
            if (nums[i] == val) {
                for (int j = i + 1; j < size; j++) {
                    nums[j-1] = nums[j];
                }
                size--;
                i--;
            }
        }
        return size;
    }
}

这是两个for循环的暴力解法，时间复杂度O(n^2)。

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow = 0;
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast] != val) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

这是快慢指针法，规避了两个for循环的弊端，时间复杂度为O(n)。

【另】为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}