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

今日内容

• 数组理论基础
• leetcode.704 二分查找
• leetcode.27 移除元素
• leetcode.977 有序数组的平方

由于之前跟着代码随想录刷过一段时间，但是期间各种事情属实是打乱了自己的刷题计划，于是这次从头再来。也正因如此，有些刷过的题目就直接上手复习了。

数组理论基础

参考链接：代码随想录 (programmercarl.com)

首先何为数组，数组就是存放在连续的内存空间上的相同类型数据的集合。

数组一旦确定了大小，就会被分配固定的连续内存空间。当我们在数组中做删除元素的操作并不是将指定元素的空间删除掉，而是使用该元素后面的元素覆盖掉。

原因就是数组的内存空间是连续的，中间删除了一个元素后，为了保证地址的连续性，就需要将后方的元素往前移动。

PS：其实上图有一点小瑕疵。删除J之后数组长度应该依然为8，在下标7的位置还是保留了B这个字符的。

二维数组在内存空间中也连续吗？

因为主用语言为Java，所以只考虑Java的情况。

在Java中，二维数组的内存空间分布可能如下图所示：

这样看来，就是一级索引的内存空间是连续的，然后每个二级索引的内存空间也是连续的。但是一级二级之间不是连续的。

Leetcode. 704 二分查找

文章链接：代码随想录 (programmercarl.com)

题目链接：704. 二分查找 - 力扣（LeetCode）

 二分法适用于：

1. 数据有序
2. 无重复元素

出现这两种情况，就可以考虑使用二分了。

在使用二分的过程中，要注意循环不变量。也就是每次循环的边界处理都要根据区间定义操作。一般区间定义有左闭右开 [a, b)，和左闭右闭 [a, b]。

下面是左闭右开的代码：

class Solution {
    public int search(int[] nums, int target) {
        // 定义左右区间
        int start = 0;
        int end = nums.length; // 因为右开，所以取不到nums.length
        // 注意边界，此时为左闭右开
        while (start < end){
            int mid = (start + end) / 2;
            if (nums[mid] == target){
                return mid;
            } else if (nums[mid] < target){
                start = mid + 1;
            } else {
                end = mid; // 区间右开，所以右区间等于mid，反正也取不到
            }
        }
        return -1;
    }
}

下面是左闭右闭的代码：

class Solution {
    public int search(int[] nums, int target) {
        // 定义左右区间
        int start = 0;
        int end = nums.length - 1; // 因为右闭，所以取得到nums.length - 1
        // 注意边界，此时为左闭右闭
        while (start <= end){
            int mid = (start + end) / 2;
            if (nums[mid] == target){
                return mid;
            } else if (nums[mid] < target){
                start = mid + 1;
            } else {
                end = mid - 1; // 区间右闭，所以右区间等于mid - 1，不然就取到mid了
            }
        }
        return -1;
    }
}

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

Leetcode. 27 移除元素

文章链接：代码随想录 (programmercarl.com)

题目链接：27. 移除元素 - 力扣（LeetCode）

暴力法

上来直接暴力解。外层循环找到符合条件的值之后，内层循环再将后面的元素往前移动。代码如下：

class Solution {
    public int removeElement(int[] nums, int val) {
        // 暴力解法
        int len = nums.length;
        for (int i = 0; i < len; i++){
            if (nums[i] == val){
                for (int j = i; j < len - 1; j++){
                    nums[j] = nums[j + 1];
                }
                len--; // 数组大小减1
                i--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
            }
        }
        return len;
    }
}

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

双指针法

本题的思想为快慢指针。

步骤：

1. 初始化快慢指针，值取0.
2. 若快指针指向的元素值不等于要删除的值，则将快指针指向元素的值赋值给慢指针指向的元素。快慢指针往后移动。
3. 若快指针指向的元素值等于要删除的值，则快指针往后移动，慢指针不动。
4. 重复2-3步。

经过此番步骤之后，慢指针指向的元素下标就是数组长度。

 代码如下：

class Solution {
    public int removeElement(int[] nums, int val) {
        // 双指针法
        int fast = 0;
        int slow = 0;
        while (fast != nums.length){
            if (nums[fast] == val){
                fast++;
            } else {
                nums[slow] = nums[fast];
                slow++;
                fast++;
            }
        }
        return slow;
    }
}

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

Leetcode. 977 有序数组的平方

文章链接：代码随想录 (programmercarl.com)

题目链接：977. 有序数组的平方 - 力扣（LeetCode）

同样的，使用双指针法。

此题一开始一直想着如何可以做到原地操作，想着想着就钻牛角尖了。结果提交的时候发现，一刷时也在这上面纠结过，没想到第二次做又掉入同一个问题中......

本题思路：使用双指针，通过对比指针指向元素的大小按序放入新数组中，再对新数组计算平方。

代码如下：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] result = new int[nums.length];
        int l = 0;
        int r = nums.length - 1;
        for (int i = result.length - 1; i >= 0; i--){
            // 要想求平方后元素按升序排序，那就得按照元素的绝对值先做排序
            if (Math.abs(nums[l]) > Math.abs(nums[r])){
                result[i] = nums[l];
                l++; // 左比右大，左指针右移
            } else {
                result[i] = nums[r];
                r--; // 右比左大，右指针左移
            }
        }
        for (int i = 0; i < result.length; i++){
            result[i] = result[i] * result[i];
        }
        return result;
    }
}

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

总结

由于不是一刷了，所以这些题目就直接上手了。好在基本思想依然记住了，只是代码书写上略逊，看来代码能力仍需提升，多敲敲吧！