代码随想录的第二天

977.有序数组的平方

暴力解法：

var sortedSquares = function(nums) {
    for (let i = 0;i < nums.length;i++) {
        nums[i] = Math.pow(nums[i], 2)
    }
    nums.sort((a,b) => a - b)
    return nums
};

双指针：

var sortedSquares = function(nums) {
    let slow = 0,fast = nums.length - 1;
    let result = []
    while (slow <= fast) {
        let nfast = Math.pow(nums[fast], 2)
        let nslow = Math.pow(nums[slow], 2)
        if (nfast < nslow) {
            let temp = nfast
            nfast = nslow
            nslow = temp
            slow++
        } else {
            fast--
        }
        result.unshift(nfast)
    }
    return result
};

双指针思路：

1、首先判断是一个有序数组，从负到正，那么两边的数肯定是大于中间的数值

2、定义慢指针从0出发，快指针倒序出发，当慢指针超过快指针结束

3、主要就是判断快指针小于慢指针的时候，就需要慢指针存数组，相当于一直存最大值，然后对应指针移动（我是换了下位置可以直接一步存储，不换的话在两个逻辑各存一遍就行）

209.长度最小的子数组

暴力解法：

var minSubArrayLen = function(target, nums) {
    let index = nums.length + 1
    let sum = 0
    for (let i = 0;i < nums.length; i++) {
        sum = 0
        for (let j = i; j < nums.length;j++) {
            sum = sum + nums[j]
            if (sum >= target) {
                const leng = j - i + 1
                index = Math.min(index, leng)
                break
            }
        }
    }
    return index === nums.length + 1 ? 0 : index
};

双指针滑动窗口解法：

var minSubArrayLen = function(target, nums) {
    let slow = 0, fast = 0,index = nums.length + 1,sum = 0
    while (fast < nums.length) {
        sum += nums[fast]
        while (sum >= target) {
            const leng = fast - slow + 1
            index = Math.min(index, leng)
            sum = sum - nums[slow]
            slow++
        }
        fast++
    }
    return index === nums.length + 1 ? 0 : index
};

思路：

1、暴力循环和滑动窗口思路其实大致一样

2、就是在起始位置不动，先去循环右边的数据，总和大于目标值后，起始位置加一继续循环右边值

3、需要注意两点：当大于目标值后，sum的值减去左边移动的值；内部使用while，因为if只会去执行一次判断，快指针就会向后跑了，所以必须将快指针停住，将里面值计算清楚再开始移动快指针

59. 螺旋矩阵 II

模拟循环：

var generateMatrix = function(n) {
    let loop = Math.floor(n / 2)
    let offset = 1
    let count = 1
    let startX = 0, startY = 0
    let mid = Math.floor(n / 2)
    let arr = new Array(n).fill(0).map(() => new Array(n).fill(0))

    while (loop--) {
        let row = startX , col = startY
        for (;col < n - offset;col++) {
            arr[row][col] = count++
        }
        for (;row < n - offset;row++) {
            arr[row][col] = count++
        }
        for (;col > startY; col--) {
            arr[row][col] = count++
        }
        for (;row > startX;row--) {
            arr[row][col] = count++
        }
        startX++
        startY++
        offset++
    }

    if (n % 2 === 1) {
        arr[mid][mid] = n*n
    }
    return arr
};

思路：

1、首先要先明白转几圈？是要转一个n平方的正方形，那么n的一半向下取整就是要旋转的圈数

2、填充数组，先横向填充n，再纵向填充n

3、开始模拟转圈，从x开始，y进行移动，每次进行加一（需要注意层级，第一次后x，y都会加一，距离边界会减一）

4、模拟完一边后，右侧的y已经变成了循环后的值，所以直接给数组赋值就行

5、最后判断n是否是奇数，如果是奇数会有中间值，就是n*n