代码随想录算法训练营第一天 | 704. 二分查找 & 27. 移除元素

拖了很久，终于还是下定决心搞一搞算法了，怕自己坚持不下来，报了个训练营，在B站上认识的卡哥，觉得讲的很不错，就跟着一起学了。

这也是第一次写博客，权当是记录一下自己的学习过程了，方便以后复习。

数组理论

• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的

正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。数组的元素是不能删的，只能覆盖。

--来自代码随想录

1. 二分查找

leetcode

视频讲解

问题：

这个自己第一遍写的时候觉得巨简单，结果leetcode上直接超时，看了下卡哥的视频，上面说的小问题全中招了。

class Solution {
    public int search(int[] nums, int target) {
        int high = nums.length - 1;
        int low = 0;
        if(target > nums[high] || target < nums[low]) return -1;
        if(target == nums[high]) return high;
        if(target == nums[low]) return low;
        int i;
        while(low < high){
            i = (high + low) / 2;
            if(target == nums[i]) return i;
            if(target > nums[i]) low = i;
            if(target < nums[i]) high = i;
        }
        return -1;
    }
}

1. 没考虑数组的区间 -- [left, right]，或者[left, right)，所以直接写了 low<high;

2. 判断target所在区间后直接将 i 赋给了 high/low，没考虑边界包不包含的问题。

学习：

1. 当 [] 时，left = right是合法的，例如 [1,1] 是合法的，其中只有一个 1，所以此时 low <= high;并且在判断了target 和 nums[i] 的大小关系后，如果不相等，则说明target一定不是nums[i]，而闭区间已经包括了nums[i], 此时应该对 i +/- 1后再赋值给 low/high。

2. 同理，当 [) 时， left = right是不合法的，例如 [1,1) 是不合法的，所以 low < high，并且 high = nums.length; 左闭已经包括了nums[i]，所以 low = i + 1，而右开不包括nums[i]，所以 high = i。

class Solution {
    //左闭右闭
    public int search(int[] nums, int target) {
        int high = nums.length - 1;
        int low = 0;
        //if(target > nums[high] || target < nums[low]) return -1;
        //if(target == nums[high]) return high;
        //if(target == nums[low]) return low;
        int i;
        while(low <= high){
            i = (high + low) / 2;
            if(target == nums[i]) return i;
            if(target > nums[i]) low = i + 1;
            if(target < nums[i]) high = i -1 ;
        }
        return -1;
    }
}

class Solution {
    //左闭右开
    public int search(int[] nums, int target) {
        int high = nums.length;
        int low = 0;
        //if(target > nums[high - 1] || target < nums[low]) return -1;
        //if(target == nums[high - 1]) return high - 1;
        //if(target == nums[low]) return low;
        int i;
        while(low < high){
            i = (high + low) / 2;
            if(target == nums[i]) return i;
            if(target > nums[i]) low = i + 1;
            if(target < nums[i]) high = i;
        }
        return -1;
    }
}

• 时间复杂度：O(log n)
• 空间复杂度：O(1）

拓展：

• 防止溢出：因为 low + high 可能会溢出， 可以改成 low + ((high - low) / 2)

-- 来自黑马java

2. 移除元素

leetcode

视频讲解

暴力解法

注意下有的地方可能会有点小问题，比方说

j 的取值

i 要 --（因为数组整体前移了一位，所有要回退，否则会跳过被删元素的下一个元素）

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

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)

双指针法

以前接触过点双指针的概念，但是自己纠结了好一会一直写不出来，就看了讲解，思路理解了还是很容易写出来的

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;
    }
}

fast一直往前找新元素

不是val 就赋给slow，并且slow再往前一位

是val fast就继续找下一位，不用管它

最后slow就是我们要的数组。