JS代码随想录（一）：数组

代码随想录

一、数组理论基础
二、LeetCode 704. 二分查找
三、LeetCode 27. 移除元素
四、LeetCode 977.有序数组的平方
五、LeetCode 209.长度最小的子数组
六、LeetCode 59.螺旋矩阵II
七、数组总结

一、数组理论基础

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

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

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

数组的元素是不能删的，只能覆盖。

二、二分查找（二分法）

题目：. - 力扣（LeetCode）

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

错解：（未使用二分法）

var search = function(nums, target) {
    for(let i = 0; i<nums.length;i++){
        if(nums[i]==target){
            return i;
        }
    }
    return -1;
};

正解：

二分法：
这道题目的前提是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件。
对于位移法和防溢出的理解：
right - left：计算两个数的差值。
(right - left) >> 1：将差值的二进制表示向右移动一位。这相当于将差值除以2，但因为是位操作，所以通常比整数除法更快。
left + ((right - left) >> 1)：将上述得到的结果加到 left 上，得到中间值 mid。

为什么要这样做而不是直接使用 (left + right) / 2 呢？

当 left 和 right 都是大整数时，left + right 可能会导致整数溢出。例如，在32位整数系统中，如果 left 是 INT_MAX（即最大的32位整数），而 right 是一个大于零的正数，那么 left + right 就会溢出。而使用位操作可以避免这种情况，因为 right - left 的结果一定是小于或等于 right 的，因此向右移动一位（即除以2）后再加上 left 就不会溢出。

左闭右闭：

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

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    // 左闭右闭
    let mid,left=0,right=nums.length-1;
    //right是数组最后一个数的下标， 要加等号是因为，左闭右闭，当l=r时，也包含在寻找的区间
    while(left<=right){
        // // 位运算 + 防止大数溢出
        mid=left+((right-left)>>1);
        // 如果mid所在的数大于目标数，就到左边找，所以right要变
        if(nums[mid]>target){
            right=mid-1;
            // 如果mid所在的数小于目标数,就到右边找,所以left改变
        }else if(nums[mid]<target){
            left=mid+1;
            // 如果刚好等于，就返回mid中位数
        }else{
            return mid;
        }
    }
    return -1;
};

左闭右开：

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

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    // 左闭右开
    let mid,left=0,right=nums.length;
    //right是数组最后一个数的下标+1， 不加等号是因为，nums[right]不在查找范围内
    while(left<right){
        // // 位运算 + 防止大数溢出
        mid=left+((right-left)>>1);
        // 如果mid所在的数大于目标数，就到左边找，所以right要变
        if(nums[mid]>target){
            right=mid;
            // 如果mid所在的数小于目标数,就到右边找,所以left改变
        }else if(nums[mid]<target){
            left=mid+1;
            // 如果刚好等于，就返回mid中位数
        }else{
            return mid;
        }
    }
    return -1;
};

三、移除元素（快慢指针法）

题目：. - 力扣（LeetCode）

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

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

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

正确：

数组里面的元素在内存地址中是连续的，是不能删除的，所以要覆盖等于val的值
双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
快指针：寻找新数组的元素，新数组就是不含有目标元素的数组
慢指针：指向更新新数组下标的位置

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function (nums, val) {
    // 慢指针
    let i = 0;
    // 快指针
    for (j = 0; j < nums.length; j++) {
        // 如果快指针不等于val，就把不等于val的值给i，实现覆盖等于val的值
        if (nums[j] != val) {
            nums[i] = nums[j];
            // 覆盖一次，i加1，最后覆盖的次数就是数组的新长度。
            i++;
        }
    }
    return i;
};

四、有序数组的平方（双指针法）

题目：. - 力扣（LeetCode）

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

正解：

双指针法：

我们可以从数组的两端向中间遍历，同时比较两端的元素平方后的大小，并将较大的那个平方值添加到结果数组的开头（因为我们是从后向前添加到结果数组的，以保持顺序）。

在JavaScript中，Array.prototype.unshift() 是一个数组方法，用于在数组的开头添加一个或多个元素，并返回新的数组长度。但是，它实际上会修改原始数组，并在其开头添加元素。

在您给出的代码示例中：

result.unshift(leftSquare); 会在 result 数组的开头添加 leftSquare 的值。
result.unshift(rightSquare); 会在 result 数组的开头添加 rightSquare 的值。

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function(nums) {
    const result = [];// 新数组存放
    // left指向开头的指针，right指向数组末尾的指针
    let left = 0, right=nums.length-1;
    // 从两端开始同时计算平方并比较
    while(left<=right){
        const lefts = Math.pow(nums[left], 2);
        const rights = Math.pow(nums[right], 2);
        // 将较大的平方值添加到结果数组的开头
        // 如果lefts大于rights，就把lefts放到新数组最前面
        if(lefts>rights){
            result.unshift(lefts);
            left++
        }else{
            // 反之，就把rights放到新数组最前面
            result.unshift(rights);
            right--;
        }
    }
    return result;
};

五、长度最小的子数组（滑动窗口）

. - 力扣（LeetCode）

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的连续

子数组

[numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

正解：

滑动窗口（双指针）：

滑动窗口。

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

var minSubArrayLen = function(target, nums) {
    // 滑动算法
    let left = 0;  
    let sum = 0;  
    // 最小长度为无穷大
    let minLength = Infinity;  
  
    for (let right = 0; right < nums.length; right++) {  
        sum += nums[right];  
  
        // 当窗口内的和大于等于目标值时，移动左指针缩小窗口  
        while (sum >= target) {  
            minLength = Math.min(minLength, right - left + 1);  
            sum -= nums[left];  
            left++;  
        }  
    }  
//  如果找到了，就返回最小子数组的长度；如果没有找到，就返回 0。
// minLength 等于 Infinity就返回0，不等于就返回minLength
    return minLength === Infinity ? 0 : minLength;   
};

六、螺旋矩阵

. - 力扣（LeetCode）

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

正解：

初始化矩阵：
首先，需要创建一个大小为 n x n 的矩阵（二维数组），并将所有元素初始化为0或者其他占位符。这个矩阵将用于存放最终的结果。

设置边界和填充数字：
确定矩阵的四个边界：上边、下边、左边和右边。开始时，上边是矩阵的第一行，下边是最后一行，左边是第一列，右边是最后一列。同时，设置一个变量来跟踪当前要填充的数字，初始值为1。

按顺时针螺旋填充：
按照“上边 → 右边 → 下边 → 左边”的顺序，依次填充数字。每次填充完一个边后，调整相应的边界，并继续填充下一个边，直到所有格子都被填满。

填充上边：从左到右，填充上边的每个格子，并将上边界下移一行。
填充右边：从上到下，填充右边的每个格子，并将右边界左移一列。
填充下边：在确保下边还有未填充的格子后，从右到左填充下边的每个格子，并将下边界上移一行。
填充左边：在确保左边还有未填充的格子后，从下到上填充左边的每个格子，并将左边界右移一列。

重复填充过程：
重复步骤3，直到所有的格子都被填满，即当前填充的数字达到 n^2 + 1（因为我们是从1开始填充的，所以当数字大于 n^2 时，说明所有格子已经填满）。

返回结果：
当所有格子都填满后，返回填充好的矩阵。

这种解题思路的关键在于如何正确地更新边界，并在填充过程中保持顺时针螺旋的顺序。通过不断地缩小边界范围，并依次填充每个边界上的格子，最终可以得到所需的矩阵。

/**
 * @param {number} n
 * @return {number[][]}
 */
var generateMatrix = function(n) {
    // 初始化一个 n x n 的二维数组（矩阵），并用 0 填充所有元素  
    let matrix = Array(n).fill(0).map(() => Array(n).fill(0));  
  
    // 初始化要填充的数字为 1  
    let num = 1;  
  
    // 定义矩阵的四个边界：上、下、左、右  
    let rowStart = 0, rowEnd = n - 1, colStart = 0, colEnd = n - 1;  
  
    // 当要填充的数字小于等于 n^2 时，继续填充  
    while (num <= n * n) {  
        // 从左到右填充上边界（横向）  
        for (let j = colStart; j <= colEnd; j++) {  
            matrix[rowStart][j] = num++;  
        }  
        // 上边界填充完毕后，上边界下移一行  
        rowStart++;  
  
        // 从上到下填充右边界（纵向）  
        for (let i = rowStart; i <= rowEnd; i++) {  
            matrix[i][colEnd] = num++;  
        }  
        // 右边界填充完毕后，右边界左移一列  
        colEnd--;  
  
        // 从右到左填充下边界（如果还存在未填充的元素）  
        for (let j = colEnd; j >= colStart; j--) {  
            matrix[rowEnd][j] = num++;  
        }  
        // 下边界填充完毕后，下边界上移一行  
        rowEnd--;  
  
        // 从下到上填充左边界（如果还存在未填充的元素）  
        for (let i = rowEnd; i >= rowStart; i--) {  
            matrix[i][colStart] = num++;  
        }  
        // 左边界填充完毕后，左边界右移一列  
        colStart++;  
    }  
  
    // 返回填充好的矩阵  
    return matrix; 
};