leetcode刷题——代码随想录

题目来源：@leetcode
刷题顺序：@代码随想录
使用语言：@C++

专题一.数组

一、数组理论基础

1. 数组是存放在连续内存空间上的相同类型数据的集合。
   • 数组下标都是从0开始的。
   • 数组内存空间的地址是连续的。
2. 二维数组在内存的空间地址不一定连续
   • 不同编程语言的内存管理是不一样
     • C++中二维数组是连续分布的
     • Java是没有指针的，同时也不对程序员暴露其元素的地址，寻址操作完全交给虚拟机。所以看不到每个元素的地址情况，地址没有规则，更不连续。
       

二、二分查找

1. 使用前提：
   • 数组为有序数组；
   • 数组中无重复元素。
     • 有重复元素时，二分法返回的元素下标不唯一。
2. 边界条件：
   • 要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则
   • left ：左边界；right：右边界
   • middle：二分中心
   • target：目标元素
   • 数组升序
3. 复杂度
   • 时间复杂度：O(log n)
   • 空间复杂度：O(1)
4. 左闭右闭[left, right]
   即定义target在[left, right]区间内
   • while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=；
   • if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
        while (left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=
            int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
            if (nums[middle] > target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

5. 左闭右开[left, right）
   即定义target在[left, right）区间内
   • while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
   • if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在[middle + 1, right)中
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

• 注：右边界可能小于左边界，分类讨论，具体分析
• 例题部分：
  1.

2. 
3. 
4. 
5. 

三、移除元素

1. 要求：给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。
2. 注意点：数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。
3. 方法：
   • 暴力解法——两层for循环

// 时间复杂度：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--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
};

• 双指针法——快慢指针
  • 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
  • 定义快慢指针
    • 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
    • 慢指针：指向更新的新数组下标的位置

// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

• 双指针法——相向双指针
  • 基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素

//时间复杂度：O(n)
//空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int leftIndex = 0;
        int rightIndex = nums.size() - 1;
        while (leftIndex <= rightIndex) {
            // 找左边等于val的元素
            while (leftIndex <= rightIndex && nums[leftIndex] != val){
                ++leftIndex;
            }
            // 找右边不等于val的元素
            while (leftIndex <= rightIndex && nums[rightIndex] == val) {
                -- rightIndex;
            }
            // 将右边不等于val的元素覆盖左边等于val的元素
            if (leftIndex < rightIndex) {
                nums[leftIndex++] = nums[rightIndex--];
            }
        }
        return leftIndex;   // leftIndex一定指向了最终数组末尾的下一个元素
    }
};