LeetCode刷题(ACM模式)-01数组

参考引用:代码随想录

  • 注:每道 LeetCode 题目都使用 ACM 代码模式,可直接在本地运行,蓝色字体为题目超链接

0. 数组理论基础

  • 数组(array)是存放在连续内存空间上的相同类型数据的集合,是一种复合数据类型,它是有序数据的集合,在存储空间中也是按顺序存储。数组中的每个元素具有相同的数据类型,可以方便的通过下标索引的方式访问到对应的数据。根据数组的维度,可以将其分为一维数组、二维数组和多维数组等。举一个字符数组的例子,如图所示
    • 数组下标都是从 0 开始
    • 数组内存空间的地址是连续
    • 数值数组元素的默认值为 0,而引用元素的默认值为 null
    • 数组元素可以是任何类型,包括数组类型

LeetCode刷题(ACM模式)-01数组_第1张图片

  • 正是因为数组的在内存空间的地址是连续的,所以在删除或者增添元素的时候,就难免要移动其他元素的地址。例如删除下标为 3 的元素,需要对下标为 3 的元素后面的所有元素都要做移动操作,如图所示

LeetCode刷题(ACM模式)-01数组_第2张图片

  • 要注意 vector 和 array 的区别,vector 的底层实现是 array,严格来讲 vector 是容器,不是数组。数组的元素是不能删的,只能覆盖,平时删除操作也是依次用后一位覆盖,因为存储空间申请且初始化后就固定了,如下图二维数组所示。此外,在 C++ 中二维数组也是连续分布的

LeetCode刷题(ACM模式)-01数组_第3张图片

1. 二分查找

704. 二分查找
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1

  • 示例 1
    输入: nums = [-1,0,3,5,9,12],target = 9
    输出: 4
    解释: 9 出现在 nums 中并且下标为 4
  • 示例 2
    输入: nums = [-1,0,3,5,9,12],target = 2
    输出: -1
    解释: 2 不存在 nums 中因此返回 -1
  • 提示
    你可以假设 nums 中的所有元素是不重复的
    n 将在 [1, 10000] 之间
    nums 的每个元素都将在 [-9999, 9999] 之间

1.1 解题思路

  • 使用二分法的前提条件

    • 数组为有序数组
    • 数组中无重复元素
  • 二分法核心思想

    • 在二分查找的过程中,保持不变量,即:在 while 寻找每一次边界的处理都要坚持根据区间的定义来操作,这就是循环不变量规则
    • 区间的定义一般为两种,左闭右闭即 [left, right],或者左闭右开即 [left, right)

1.2 二分法之左闭右闭

  • 例如在数组:1,2,3,4,7,9,10 中查找元素 2,如图所示

LeetCode刷题(ACM模式)-01数组_第4张图片

// 时间复杂度:O(log n)
// 空间复杂度:O(1)
#include 
#include 

class Solution {
public:
    int search(std::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;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 1, 2, 3, 4, 7, 9, 10 };
    int target = 2;

    Solution solution;
    int result = solution.search(nums, target);

    std::cout << result << std::endl;
    return 0;
}

1.3 二分法之左闭右开

// 时间复杂度:O(log n)
// 空间复杂度:O(1)
#include 
#include 

class Solution {
public:
    int search(std::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) / 2;
            if (nums[middle] > target) {
                right = middle;
            } else if (nums[middle] < target) {
                left = middle + 1;
            } else {
                return middle;
            }
        }
        return -1;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 1, 2, 3, 4, 7, 9, 10 };
    int target = 2;

    Solution solution;
    int result = solution.search(nums, target);

    std::cout << result << std::endl;
    return 0;
}

2. 移除元素

27. 移除元素
给你一个数组 nums 和一个值 val,你需要原地移除所有数值等于 val 的元素,并返回移除后数组的新长度。不要使用额外的数组空间,你必须仅使用 O ( 1 ) O(1) O(1) 额外空间并原地修改输入数组

  • 示例 1
    给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2
  • 示例 2
    给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4
  • 提示
    元素的顺序可以改变
    你不需要考虑数组中超出新长度后面的元素
    数组的元素在内存地址中是连续的,不能单独删除数组中的某个元素,只能覆盖
    数组在内存中是连续的地址空间,不能释放单一元素,如果要释放,就是全释放(程序运行结束,回收内存栈空间)

2.1 暴力解法

  • 两层 for 循环,第一个 for 循环遍历数组元素 ,第二个 for 循环更新数组
// 时间复杂度:O(n^2)
// 空间复杂度:O(1)
#include 
#include 

class Solution {
public:
    int removeElement(std::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+1)
                // 从而导致这个位置上的元素没有被处理到
                --i;
                --size; // 此时数组的大小 -1
            }
        }
        return size;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 0, 1, 2, 2, 3, 0, 4, 2 };

    Solution solution;
    int result = solution.removeElement(nums, 2);

    std::cout << result << std::endl;
    return 0;
}

2.2 双指针法

  • 双指针法(快慢指针法):通过一个快指针和慢指针在一个 for 循环下完成两个 for 循环的工作
  • 定义快慢指针
    • 快指针:寻找新数组的元素,新数组就是不含有目标元素的数组
    • 慢指针:指向更新的新数组下标的位置
// 时间复杂度:O(n)
// 空间复杂度:O(1)
#include 
#include 

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

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 0, 1, 2, 2, 3, 0, 4, 2 };

    Solution solution;
    int result = solution.removeElement(nums, 2);

    std::cout << result << std::endl;
    return 0;
}

3. 有序数组的平方

977. 有序数组的平方
给你一个按非递减顺序排序的整数数组 nums,返回每个数字的平方组成的新数组,要求也按非递减顺序排序

  • 示例 1
    输入:nums = [-4,-1,0,3,10] 输出:[0,1,9,16,100] 解释:平方后,数组变为 [16,1,0,9,100],排序后,数组变为 [0,1,9,16,100]
  • 示例 2
    输入:nums = [-7,-3,2,3,11] 输出:[4,9,9,49,121]

3.1 暴力解法

  • 每个数平方之后,排个序
// 时间复杂度:O(n + nlogn)
#include 
#include 
#include 

class Solution {
public:
    std::vector<int> sortedSquares(std::vector<int> &A) {
        for (int i = 0; i < A.size(); ++i) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序
        return A;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> A{ -7, -3, 2, 3, 11 };

    Solution solution;
    std::vector<int> result = solution.sortedSquares(A); // 调用快速排序算法

    // 打印排序后的数组
    for (auto i = result.begin(); i < result.end(); ++i) {
        std::cout << *i << ' ';
    }
    
    return 0;
}

3.2 双指针法

  • 数组其实是有序的,只不过负数平方之后可能成为最大数了。那么数组平方的最大值就在数组的两端,不是最左边就是最右边,不可能是中间。此时可以考虑双指针法了,i 指向起始位置,j 指向终止位置。定义一个新数组 result,和 A 数组一样的大小
    如果 A[i] * A[i] < A[j] * A[j] 那么 result[k--] = A[j] * A[j]; 
    如果 A[i] * A[i] >= A[j] * A[j] 那么 result[k--] = A[i] * A[i];
    

// 时间复杂度:O(n)
#include 
#include 

class Solution {
public:
    std::vector<int> sortedSquares(std::vector<int> &A) {
        std::vector<int> result(A.size());
        // 定义左右指针,初始时分别指向数组的第一个和最后一个元素
        int left = 0;
        int right = A.size() - 1;
        // 从右向左遍历数组
        for (int i = A.size() - 1; i >= 0; --i) {
            // 取左右指针指向的数的平方的较大值添加到结果中,并将左右指针向中间移动
            if (A[left] * A[left] >= A[right] * A[right]) {
                result[i] =  A[left] * A[left];
                ++left;
            } else {
                result[i] = A[right] * A[right];
                --right;
            }
        }
        return result;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> A{ -7, -3, 2, 3, 11 };
    Solution solution;
    std::vector<int> result = solution.sortedSquares(A); // 调用快速排序算法

    // 打印排序后的数组
    for (auto i = result.begin(); i < result.end(); ++i) {
        std::cout << *i << ' ';
    }
    
    return 0;
}

4. 长度最小的子数组

209. 长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的连续子数组,并返回其长度。如果不存在符合条件的子数组,返回 0

  • 示例 1
    输入:s = 7, nums = [2,3,1,2,4,3] 输出:2 解释:子数组 [4,3] 是该条件下的长度最小的子数组
  • 提示
    1 <= target <= 10^9
    1 <= nums.length <= 10^5
    1 <= nums[i] <= 10^5

滑动窗口法

  • 所谓滑动窗口(也可以理解为双指针法的一种),就是不断的调节子序列的起始位置和终止位置,从而得出要想的结果。在暴力解法中,是一个 for 循环为滑动窗口的起始位置,另一个 for 循环为滑动窗口的终止位置,用两个 for 循环 完成了一个不断搜索区间的过程。那么滑动窗口如何用一个 for 循环来完成这个操作呢?

    • 首先要思考:如果用一个 for 循环,那么应该表示滑动窗口的起始位置,还是终止位置。只用一个 for 循环,那么这个循环的索引,一定是表示滑动窗口的终止位置。那么问题来了,滑动窗口的起始位置如何移动呢?这里还是以题目中的示例来举例,s=7,数组是 2,3,1,2,4,3,来看一下查找的过程
  • 在本题中实现滑动窗口,主要确定如下三点

    • 窗口内是什么?
      • 窗口就是满足其和 ≥ s 的长度最小的连续子数组
    • 如何移动窗口的起始位置?
      • 如果当前窗口的值大于 s 了,窗口就要向前移动了(也就是该缩小了)
    • 如何移动窗口的结束位置?
      • 窗口的结束位置就是遍历数组的指针,也就是 for 循环里的索引
  • 解题的关键在于窗口的起始位置如何移动,滑动窗口的精妙之处在于,根据当前子序列和大小的情况,不断调节子序列的起始位置,从而将 O ( n 2 ) O(n^2) O(n2) 暴力解法降为 O ( n ) O(n) O(n):每个元素在滑动窗后进来操作一次,出去操作一次,每个元素都是被操作两次,所以时间复杂度是 2n 也就是 O ( n ) O(n) O(n)

// 时间复杂度:O(n)
// 空间复杂度:O(1)
#include 
#include 

class Solution {
public:
    int minSubArrayLen(int target, std::vector<int> &nums) {
        int result = INT32_MAX; // 子数组初始值
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度

        for (int j = 0; j < nums.size(); ++j) { // j 滑动窗口终止位置
            sum += nums[j];
            // 使用 while,每次更新 i(起始位置),并不断比较子序列是否符合条件
            while (sum >= target) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i]; // 不断变更 i(子序列的起始位置)
                ++i;
            }
        }
        // 如果 result 没有被赋值的话,就返回 0,说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

int main(int argc, char *argv[]) {
    std::vector<int> nums{ 2, 3, 1, 2, 4, 3 };
    int target = 7;

    Solution solution;
    std::cout << solution.minSubArrayLen(target, nums) << std::endl;
    
    return 0;
}

5. 螺旋矩阵II

59. 螺旋矩阵 II
给定一个正整数 n,生成一个包含 1 到 n 2 n^2 n2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵

  • 示例
    输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

5.1 思路

  • 核心思想:循环不变量原则
    • 模拟顺时针画矩阵的过程,一圈下来要画每四条边,每画一条边都坚持一致的左闭右开(或左开右闭)原则
    • 下图每一种颜色代表一条边及遍历的长度,可以看出每一个拐角处的处理规则,拐角处让给新的一条边来继续画,即左闭右开的原则
      • 填充上行从左到右
      • 填充右列从上到下
      • 填充下行从右到左
      • 填充左列从下到上

LeetCode刷题(ACM模式)-01数组_第5张图片

5.2 代码实现

// 时间复杂度 O(n^2): 模拟遍历二维矩阵的时间
// 空间复杂度 O(1)
#include 
#include 

class Solution {
public:
    std::vector<std::vector<int>> generateMatrix(int n) {
        std::vector<std::vector<int>> res(n, std::vector<int>(n, 0)); // 使用vector定义一个二维数组,每个位置初始化为0
        int startx = 0, starty = 0; // 定义每循环一个圈的起始位置
        int loop = n / 2; // 每个圈循环几次,例如n为奇数3,那么loop = 1 只是循环一圈,矩阵中间的值需要单独处理
        int mid = n / 2; // 矩阵中间的位置,例如:n为3,中间的位置就是(1,1),n为5,中间位置为(2, 2)
        int count = 1; // 用来给矩阵中每一个空格赋值
        int offset = 1; // 需要控制每一条边遍历的长度,每次循环右边界收缩一位
        int i,j;
        while (loop--) {
            i = startx;
            j = starty;

            // 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
            for (j = starty; j < n - offset; j++) {
                res[i][j] = count++;
            }
            // 模拟填充右列从上到下(左闭右开)
            for (i = startx; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟填充下行从右到左(左闭右开)
            for (; j > starty; j--) {
                res[i][j] = count++;
            }
            // 模拟填充左列从下到上(左闭右开)
            for (; i > startx; i--) {
                res[i][j] = count++;
            }

            // 第二圈开始的时候,起始位置要各自加1, 例如:第一圈起始位置是(0, 0),第二圈起始位置是(1, 1)
            startx++;
            starty++;

            // offset 控制每一圈里每一条边遍历的长度
            offset += 1;
        }

        // 如果n为奇数的话,需要单独给矩阵最中间的位置赋值
        if (n % 2) {
            res[mid][mid] = count;
        }
        return res;
    }
};

int main(int argc, char *argv[]) {
    Solution solution;
    int n = 3;

    std::vector<std::vector<int>> res = solution.generateMatrix(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            std::cout << res[i][j] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

你可能感兴趣的:(LeetCode刷题,学习,c++,leetcode,算法,数据结构)