(1/60)数组理论基础、二分查找、移除元素

代码随想录训练营day1，学习了数组基础、二分查找（二分法）、移除元素（暴力、同向双指针、相向双指针）。通过写博客确实感觉对问题深入很多，但是想好好写还是蛮难的（很花时间），后续可能要简化一些才好坚持写下去。

数组基础理论

定义

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

注意点

1. 下标从0开始。大小为n的数组下标范围是0~n-1。
2. 一维数组内存空间地址是连续的，在增删元素时会对其他元素地址产生影响。（二维数组）
3. 数组元素不能删除，只能覆盖。

---

二分查找

leetcode：704.二分查找

文档：二分查找

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

二分法

思路

对一个有序数据集合不断进行划分为两个子集、查找目标元素，以求解问题。（可以理解为分治法的一种具体应用）

具体步骤：

1. 数据集合排序。

2. 确定集合中间元素，根据其划分为两个子集。

3. 中间元素与目标元素比较，确定可能的子集，查找范围减半。

4. 重复2、3直至找到目标或确定目标不存在。

复杂度分析

时间复杂度：O(logN)

空间复杂度：O(1)

注意点

1. 循环不变量原则。选定一个变量取值范围的原则始终如一地写下去。此处学习两种：[左闭,右闭]、[左闭,右开)
2. 具体写码时只需注意：
   • 下标初始化是否取有意义元素下标
   • 循环条件是否取等号
   • 比较后下标更新时是否要取有意义元素的下标

代码实现

左闭右闭写法

class Solution {
public:
    // 左闭右闭写法
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;    // 右闭，right就是最后一个元素
        int mid = (left + right)/2;
        while(left <= right){   // 举例[1,1]合法，所以应该为<=
            if(nums[mid] > target){
                right = mid - 1;    // 右闭，所以要取到有意义的值上(mid-1)
            }else if(nums[mid] < target){
                left = mid + 1;
            }else{
                return mid; // 如果相等直接返回下标
            }
            mid = (left + right)/2;     // 更新mid
        }
        // 循环结束也没找到，元素不存在
        return -1;
    }
};

左闭右开写法

class Solution {
public:
    // 左闭右开写法
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size();    // 右开，right应该为最后一个元素的下一个
        int mid = (left + right)/2;
        while(left < right){   // 举例[1,1)不合法，所以应该为<
            if(nums[mid] > target){
                right = mid;    // 右开，所以要取到最后有意义值的下一个 mid
            }else if(nums[mid] < target){
                left = mid + 1;
            }else{
                return mid; // 如果相等直接返回下标
            }
            mid = (left + right)/2;     // 更新mid
        }
        // 循环结束也没找到，元素不存在
        return -1;
    }
};

对应的，可以看到两种写法就几处位置不同：

1. 初始化right是取数组末元素下标还是末元素下一位
2. while判断条件有没有=
3. 循环内right更新是取数组末元素mid-1还是它的下一位（比较后，mid-1为有意义数组的末元素下标）

---

移除元素

leetcode：27.移除元素

代码随想录：移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

暴力法

思路

两层for循环，外层寻找==val的元素，内层将数组整体前移。

复杂度分析

时间复杂度：O(n^2)，二重循环

空间复杂度：O(1)，无额外数组空间

注意点

1. 变量取值范围用新声明的size，动态变化，而不是写死的nums.size()
2. 依旧是循环不变量原则，整体移动数组时，右开原则用j+1就要收尾巴（j < size - 1），用j-1就要伸脖子（int j = i+1）。

for(int j = i;j < size - 1;j++){   // 二层把数组整体往前挪
	nums[j] = nums[j+1];    // 右开为size-1，保证j+1最大取size-1，不越界。
}

代码实现

class Solution {
public:
    // 暴力法，双重循环
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size(); // 新数组大小，动态变化
        for(int i = 0;i < size;){ // 一层寻找目标元素
            if(nums[i] == val){ // 找到了，覆盖元素，指针保持不动
                for(int j = i;j < size - 1;j++){   // 二层把数组整体往前挪
                    nums[j] = nums[j+1];    // 右开为size-1，保证j+1最大取size-1，不越界。
                }
                size--;
            }else{  // 没找到，指针后探
                i++;
            }
        }

        return size;
    }
};

同向双指针法

思路

同向一快一慢双指针，快指针寻找目标元素， 慢指针在原数组上覆盖去除val后的元素。（此方法没有改变元素相对位置）

1. 快指针后探寻找目标元素
2. 如果是非目标元素，快指针后探，慢指针保持不动，数组size--；否则慢指针复制快指针元素并后移
3. 重复1、2完整遍历原数组

复杂度分析

时间复杂度：O(n)

空间复杂度：O(1)

注意点

1. 由于双指针并没有整体移动数组，数组有意义部分大小没有减少，需要把原数组完整遍历一遍。(要用nums.size())

代码实现

class Solution {
public:
    // 同向双指针（快慢指针）
    int removeElement(vector<int>& nums, int val) {
        int fast = 0;
        int slow = 0;
        int size = nums.size();

        for(;fast < nums.size();fast++){  
            // 外层循环，快指针后探，
            // 双指针法没有整体移动数组，
            // 因此要探完，不能用新定义的size
            if(nums[fast] != val){  // 如果没找到，慢指针copy快指针并后移
                nums[slow++] = nums[fast];
            }else{  // 否则快指针后移，慢指针保持不动
                size--;
            }   
        }

        return size;
    }
};

相向双指针法

思路

左右双指针向中间探索，左指针寻找val，右指针寻找非val，将左指针找到的val替换为右指针的非val，从而删除数组中==val的元素。

1. 首先左指针向右探，寻找等于val的元素。
2. 然后右指针向左探，寻找不等于val的元素。
3. 如果left < right，左指针元素赋值为右指针元素。
4. 重复1、2、3直至left > right，此时left恰好为新数组大小。

复杂度分析

时间复杂度：O(n)，看似两个循环，其实只有O(n)次操作（遍历一遍数组）

空间复杂度：O(1)

注意点

1. 相向双指针用左指针left代表大小，不用size。

2. 进行赋值后，原来各自指向的元素都已经处理过了，左右指针都要移动，向中间靠拢。

3. 如果一轮移动后满足left < right，说明都左右指针正常找到了对应元素，那么进行赋值；否则至少一端出现了异常，不进行赋值。

4. 循环大条件是left <= right，对于left来说就是右闭，因此循环结束后一定是恰好left > right。又因为是先进行的左指针右探，所以导致left > right的最终操作也一定是left++，因此循环结束后left恰好是有意义数组末元素的下一位，也就刚好等于新数组大小。

代码实现

class Solution {
public:
    // 相向双指针
    int removeElement(vector<int>& nums, int val) {
        // 左闭右闭原则
        int left = 0;
        int right = nums.size() - 1;
        while(left <= right){
            // 左指针找val
            while(left <= right && nums[left] != val){
                left++;
            }
            // 右指针找非val
            while(left <= right && nums[right] == val){
                right--;
            }
            // 左指针赋值为右指针
            // left < right是正常各找各的找到了的情况，进行赋值，赋值后都向中间靠拢
            // 因为条件不同，不存在left==right的情况
            if(left < right){
                nums[left++] = nums[right--];
            }
        }
        // 由于先进行left循环后探，且left遵循右闭原则
        // 所以结束循环后left刚好到非法范围（末元素下一位），也就是size
        return left;
    }
};