LeetCode刷题------数组

Kw_Chng

已于 2023-02-11 12:03:05 修改

阅读量647

点赞数

分类专栏： LeetCode刷题文章标签： leetcode 算法数据结构

于 2023-02-04 16:31:01 首次发布

本文链接：https://blog.csdn.net/weixin_43526403/article/details/128882052

版权

LeetCode刷题专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、存储方式

LeetCode：704.二分查找

写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。

LeetCode：209.长度最小的子数组

<扩展>相关题目

LeetCode：59.螺旋矩阵II

<扩展>相关题目

一、存储方式

数组是存放在连续内存空间上的相同类型数据的集合。数组可以方便的通过下标索引的方式获取到下标下对应的数据。

数组下标都是从0开始的。
数组内存空间的地址是连续的

正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。数组的元素是不能删的，只能覆盖。

LeetCode：704.二分查找

这道题目的前提是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件，当大家看到题目描述满足如上条件的时候，可要想一想是不是可以用二分法了。

写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。

1、分法第一种写法

第一种写法，我们定义 target 是在一个在左闭右闭的区间里，也就是[left, right] （这个很重要非常重要）。区间的定义这就决定了二分法的代码应该如何写，因为定义target在[left, right]区间，所以有如下两点：

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

2、二分法第二种写法

如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。有如下两点：

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

// 写法一： 左闭右闭  （就记这个）

var search = function(nums, target) {
    let mid = 0, left = 0, right = nums.length - 1;
    while (left <= right) {
        mid = left + (left + right) // 2;
        if (nums[mid] === target) {
            return mid;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1;
};


// 写法二： 左闭右开

var search = function(nums, target) {
    // right是数组最后一个数的下标+1，nums[right]不在查找范围内，是左闭右开区间
    let mid, left = 0, right = nums.length;    
    // 当left=right时，由于nums[right]不在查找范围，所以不必包括此情况
    while (left < right) {
        // 位运算 + 防止大数溢出
        mid = left + ((right - left) >> 1);
        // 如果中间值大于目标值，中间值不应在下次查找的范围内，但中间值的前一个值应在；
        // 由于right本来就不在查找范围内，所以将右边界更新为中间值，如果更新右边界为mid-1则将中间值的前一个值也踢出了下次寻找范围
        if (nums[mid] > target) {
            right = mid;  // 去左区间寻找
        } else if (nums[mid] < target) {
            left = mid + 1;   // 去右区间寻找
        } else {
            return mid;
        }
    }
    return -1;
};

<扩展>带有重复元素的升序数组，寻找第一个、最后一个target

<扩展>相关题目

LeetCode：27.移出元素

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组
慢指针：指向更新新数组下标的位置

var removeElement = function(nums, val) {
    let k = 0;
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] != val) {
            nums[k++] = nums[i];        
        }
    }
    return k;
};

<扩展>暴力：两层for循环，一个for循环遍历数组元素，第二个for循环更新数组。时间复杂度是O(n^2)

<扩展>相关题目

26.删除排序数组中的重复项
283.移动零
844.比较含退格的字符串
977.有序数组的平方

LeetCode：977.有序数组的平方

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

如果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];

var sortedSquares = function(nums) {
    let res = new Array(nums.length).fill(0);
    let i = 0, j = nums.length - 1, k = nums.length - 1;   // k: res数组最后一位索引，从大到小排序
    while(i <= j) {
        let left = nums[i] ** 2; 
        let right = nums[j] ** 2;
        if (left < right) { // 如果left平方<right平方
            res[k] = right;  // res大的那位为right
            j --; // right左移
            k --;  //k左移
        } else {
            res[k] = left;  // res大的那位为left
            i ++; // i右移
            k --;  // k左移
        }
    }
    return res;
};

<扩展>暴力：每个数平方之后，排个序。时间复杂度是 O(n + nlogn)

LeetCode：209.长度最小的子数组

数组操作中另一个重要的方法：滑动窗口。所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环完成了一个不断搜索区间的过程。

那么滑动窗口如何用一个for循环来完成这个操作呢。首先要思考如果用一个for循环，那么应该表示滑动窗口的起始位置，还是终止位置。如果只用一个for循环来表示滑动窗口的起始位置，那么如何遍历剩下的终止位置？此时难免再次陷入暴力解法的怪圈。所以只用一个for循环，那么这个循环的索引，一定是表示滑动窗口的终止位置。

在本题中实现滑动窗口，主要确定如下三点：

窗口内是什么？
如何移动窗口的起始位置？
如何移动窗口的结束位置？

窗口就是满足其和 ≥ s 的长度最小的连续子数组。窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

var minSubArrayLen = function(target, nums) {
    let start = 0, end = 0, sum = 0; // 设置窗口起始、终止、元素之和
    let ans = Infinity;  // 无穷大
    while (end < nums.length) { // 窗口终止元素未超过数组长度
        sum += nums[end]; // 计算窗口内元素之和
        while (sum >= target) { // 窗口元素和>=target
            ans = Math.min(ans, end - start + 1); // 记录窗口长度
            sum -= nums[start]; // 窗口元素要向后移一位，所以去掉窗口首元素
            start ++;  // 窗口起始元素向数组后移一位
        }
        end++;  // 如果窗口内元素之和<target，增加窗口长度，窗口终止元素向数组后移一位
    }
    return ans === Infinity ? 0 : ans;
};

滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

<扩展>暴力：两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是O(n^2)。

<扩展>相关题目

904.水果成篮
76.最小覆盖子串

LeetCode：59.螺旋矩阵II

这道题目可以说在面试中出现频率较高的题目，本题并不涉及到什么算法，就是模拟过程，但却十分考察对代码的掌控能力。模拟顺时针画矩阵的过程：

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

由外向内一圈一圈这么画下去。这四条边怎么画，每画一条边都要坚持一致的左闭右开，或者左开右闭的原则，这样这一圈才能按照统一的规则画下来。

var generateMatrix = function(n) {
    let res = new Array(n).fill(0).map(()=>new Array(n).fill(0));
    let startX = startY = 0;  // 起始位置
    let loop = Math.floor(n / 2);  // 旋转圈数
    let mid = Math.floor(n / 2);  // 矩阵中心位置
    let offset = 1;  // 每一层不用填的个数
    let count = 1;  // 矩阵元素的具体值
    while (loop--) {
        let row = startX,   // 行 
        col = startY;   // 列
        // 上行从左到右（左闭右开）
        for (; col < startY + n - offset; col++) {
            res[row][col] = count++;
        }
        // 右列从上到下（左闭右开）
        for (; row < startX + n - offset; row++) {
            res[row][col] = count++;
        }
        // 下行从右到左（左闭右开）
        for (; col > startY; col--) {
            res[row][col] = count++;
        }
        // 左列做下到上（左闭右开）
        for (; row > startX; row--) {
            res[row][col] = count++;
        }
        // 更新起始位置
        startX++;
        startY++;

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