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

数组理论基础

文章链接：https://programmercarl.com/%E6%95%B0%E7%BB%84%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

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

• 查找：下标索引

  • 下标从0开始
  • 内存空间是连续的

• 删除：移动覆盖

• 二维数组内存：

  • c++ —— 连续分布

  • java
    

704、二分查找

题目链接：https://leetcode.cn/problems/binary-search/

文章讲解：https://programmercarl.com/0704.%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE.html

视频讲解：https://www.bilibili.com/video/BV1fA4y1o715

左闭右闭【】:target在【left，right】区间中：

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) >> 1);
            if(nums[middle] > target){
                right = middle - 1;
            }else if(nums[middle] < target){
                left = middle + 1;
            }else{
                return middle;
            }
        }
        return -1;
    }
};

左闭右开【）：target在【left，right）区间中

• left<right：因为当left=right时，数组元素不存在，所以无意义

• right= middle：因为【left，right）right不参与比较，因为循环条件为left<right

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、移除元素

题目链接：https://leetcode.cn/problems/remove-element/

文章讲解：https://programmercarl.com/0027.%E7%A7%BB%E9%99%A4%E5%85%83%E7%B4%A0.html

视频讲解：https://www.bilibili.com/video/BV12A4y1Z7LP

暴力解法：循环查找val，找到后，循环覆盖

• 不改变数组元素的相对顺序

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

• 空间复杂度：O(1)

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

快慢指针：相当于重新构造数值，放入不等于val的值

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置
• 时间复杂度：O(n)
• 空间复杂度：O(1)

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //双指针法
        int slowIndex = 0;
        int size = nums.size();
        for (int fastIndex = 0; fastIndex < size; fastIndex++){
            if(nums[fastIndex] != val){
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

相向双指针：从左寻找需要被替换的val，从右寻找可以替换的值

• 改变了数组元素相对位置，确保移动了最少的元素
• 时间复杂度：O(n)
• 空间复杂度：O(1)

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的值，val跳过相当于删除
             while((left <= right) && nums[right] == val){
                 right--;
             }
             //替换
             if(left < right){
                 nums[left++] = nums[right--];
             }
        }
        return left;
    }
};