leetcode刷题day1|数组部分（ 704. 二分查找、27. 移除元素）

704.二分查找

总结知识点：

1、使用二分查找的条件：有序数组，无重复元素（重复元素会使返回的下标不唯一）

2、区间的定义：左闭右闭[left, right]还是左闭右开区间[left, right)。我在这里犯了一个错是之前做过一遍记得自己right的初始值赋错了，应该要等于长度，我写成最后一个数组的下标了，所以这里right初始赋值为nums.length+1就错了，应该是nums.length-1

3、防止溢出

middle = left + ((right - left) / 2)

总的来说，这个题记住左闭右闭[left, right]的写法就可以了。Java代码如下：

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

代码随想录给出了优化提升版本：

class Solution {
    public int search(int[] nums, int target) {
        // 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
        if (target < nums[0] || target > nums[nums.length - 1]) {
            return -1;
        }
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target) {
                return mid;
            }
            else if (nums[mid] < target) {
                left = mid + 1;
            }
            else { // nums[mid] > target
                right = mid - 1;
            }
        }
        // 未找到目标值
        return -1;
    }
}

27. 移除元素

使用暴力解法

class Solution {
    public int removeElement(int[] nums, int val) {
        int k=nums.length;
        for(int i=0;i<nums.length;i++){
            if(nums[i]==val){
                for(int j=i;j<nums.length-1;j++){
                    nums[j]=nums[j+1];
                }
                k--;
                i--;//下标向前移一位
            }
        }
        return k;
    }
}

暴力解法超出时间限制，所以考虑双指针方法。

优先学习快慢指针法，解题的核心思路是快指针代表原来的数组，慢指针代表就的数组，快指针不断向前走，没有遇到val时就把值赋给慢指针，遇到了不管继续向前走。代码如下：

class Solution {
    public int removeElement(int[] nums, int val) {
        //思路：fast不断向前走，没有遇到val时就把值赋给slow，遇到了不管继续向前走。
        int slow=0;
        for(int fast=0;fast<nums.length;fast++){
            if(nums[fast]!=val){
                nums[slow++]=nums[fast];
            }
        }
        return slow;
    }
}

注意：结束循环时，fast=nums.length，slow也是新数组的数组长度，所以可以直接返回。

977.有序数组的平方

考虑使用双指针，比较第一个元素的平方和最后一个元素的平方，大的放在后面。自己写的代码如下：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int len=nums.length;
        int[] new_nums=new int[len];
        int left=0,right=len-1;
        while(left<=right){
            if(nums[left]*nums[left]>=nums[right]*nums[right]){
                new_nums[len-1]=nums[left]*nums[left];
                left++;
            }else{
                new_nums[len-1]=nums[right]*nums[right];
                right--;
            }
            len--;
        }
        return new_nums;
    }
}

代码随想录给出了比较好的解法，为新数组设置了一个下标变量index，代码如下：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int right = nums.length - 1;
        int left = 0;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                // 正数的相对位置是不变的， 需要调整的是负数平方后的相对位置
                result[index--] = nums[left] * nums[left];
                ++left;
            } else {
                result[index--] = nums[right] * nums[right];
                --right;
            }
        }
        return result;
    }
}