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

数组理论基础

数组主要考察对代码的掌握能力

数组是存放在连续内存空间上的相同类型数据的集合

数据可以方便地通过下标索引地方式获取到下标下对应的数据

• 数组下标都是从 0 开始的
• 数组内存空间的地址是连续的
  
  数组的元素是不能删的，只能覆盖

区分 vector 和 array 的区别：vector 底层实现是 array，严格讲 vector 是容器，不是数组

二维数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PU8UNf6G-1663769251920)(https://code-thinking.cdn.bcebos.com/pics/%E7%AE%97%E6%B3%95%E9%80%9A%E5%85%B3%E6%95%B0%E7%BB%842.png)]

C++ 中二维数组是连续分布的，测试代码如下：

void test_arr() {
    int array[2][3] = {
		{0, 1, 2},
		{3, 4, 5}
    };
    cout << &array[0][0] << " " << &array[0][1] << " " << &array[0][2] << endl;
    cout << &array[1][0] << " " << &array[1][1] << " " << &array[1][2] << endl;
}

int main() {
    test_arr();
}

测试的地址如下，地址为 16 进制，可以看出二维数组地址是连续一条线的（int 型数组，两个相邻数组元素地址差 4 个字节）

0x7ffee4065820 0x7ffee4065824 0x7ffee4065828
0x7ffee406582c 0x7ffee4065830 0x7ffee4065834

704. 二分查找

题目：给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1：

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

重点：边界的处理规则，是根据区间的定义来写的

左闭右闭写法

left = 0;

right = numsize - 1

while(left __ right) left 和 right 用 < 还是 <=，主要是看左闭右闭还是左闭右开（左开右闭很少见），判断 left 和 right 如果相等，在区间内是否是合法的，如果是 [left, right]，那就可以用 <=，比如是 [1, 1]，那区间内只有一个元素 1，也没问题

中间值 middle = (left + right)/2，要小心两个 int 型相加可能会越界，但在本题不会有这种情况出现

• 防止溢出写法：`int middle = left + ((right - left) / 2)；

当 if(middle > target)，更新左区间的右边界，那就应该是 right 值往回缩，但要判断 right = middle还是 right = middle-1，依然是看区间，本题中是左闭右闭，所以 right 缩了之后仍然包含在区间内，且 middle 已经 > target，所以 middle 一定不是我们要搜索的值，right 也就不能 = middle。所以接下来的区间一定不能包含原来的 middle，所以接下来的区间应该是 right = middle - 1

else if(middle < target) 同理，应该更新右区间的左边界，left = middle + 1

else return middle;，说明相等，就是想要的数了

如果都没有找到，记得 return -1

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

左闭右开写法

left = 0;

right = numsize，因为区间不包含右边界，所以多出来的那个 1 本来就不包含，不用减掉

[1, 1) 不是一个合法的区间，所以类推 while(left __ right) 不能再用等于了，因为区间没有意义，只能是 <

同理开始更新左区间的右边界，因为 right 不再包含，同时 middle > target，所以下一次搜索的左区间不包含 middle 的数值，因此 right = middle;

右区间的左边界更新，因为区间仍然包含 left，同时 middle 已经验证不是所需值，所以 left = middle + 1;

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); 
        while (left < right) { 
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; 
            } else if (nums[middle] < target) {
                left = middle + 1;
            } else { 
                return middle; 
            }
        }
        return -1;
    }
};

注意点

前提条件要满足

• 有序数组
• 数组中无重复元素

总结

记住 循环不变量 规则，区间的定义就是不变量

27. 移除元素

erase 是一个 时间复杂度 O(n) 的操作

使用库函数的时机：如果一道题调用库函数就可以直接解决了，就不要用

暴力解法

两个 for 循环，遇到与目标元素相同，就把后面的元素顶上来

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

双指针思路

通过一个快指针和慢指针在一个 for 循环下完成两个 for 循环工作

定义快慢指针

• 快指针：寻找新数组的元素，新数组就是不包含要删除元素的数组
• 慢指针：更新新数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bVTgX8ya-1663769251921)(https://tva1.sinaimg.cn/large/008eGmZEly1gntrds6r59g30du09mnpd.gif)]

• 快指针先移动，如果不是目标元素，快指针指向就赋值给慢指针指向，慢指针移动

• 如果是目标元素，则慢指针不操作，快指针继续移动。

• 慢指针最后指向的下标，就是新数组中的大小

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

复杂度

时间复杂度：O(n)

空间复杂度：O(1)

感想

全程用了两个小时左右，主要的思路之前其实就掌握了，更多是一些细节上的补充让自己对二分法的理解更深！