学习内容

• 双指针
• 滑动窗口
• 区间定义

习题：

977.有序数组的平方
209.长度最小的子数组
59.螺旋矩阵II

习题总结

977.有序数组的平方

还是双指针思想，数组的开头i，结尾j，一定是比较大的元素，越向中间越小

实现了，但是时间和内存效果都不好，还是要改进

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function(nums) {
    if(nums[0] >= 0 ){
        return nums.map(num=> num*num)
    }else if(nums[nums.length -1] <=0 ){
        return nums.reverse().map(num=> num*num)
    }else{
        let result = []
        for(let i=0,j=nums.length -1;i<nums.length;i++){
            if(i === j){
                result.unshift(nums[i] * nums[i])
                break;
            }
            if(nums[i] * nums[i] >= nums[j] * nums[j]){
                result.unshift(nums[i] * nums[i])

            }else{
                result.unshift( nums[j] * nums[j])
                i--;
                j--;
            }
        }
        return result
    }
};

209 长度最小的子数组

还是双指针，只是这次左边的指针会向后移动
这里由于rightIndex对于判断result时，已经自增1了，所以相当于一个左闭右开的集合，在while时可以使用 <=判断

/**
 * @param {number} target
 * @param {number[]} nums
 * @return {number}
 */
var minSubArrayLen = function (target, nums) {
    let leftIndex = 0
    let rightIndex = 0
    let result = 0
    let min = 0
    while (rightIndex <= nums.length ) {
         if (result >= target) {
            min = min === 0 ?rightIndex - leftIndex  : Math.min(min, rightIndex - leftIndex)
            result = result - nums[leftIndex]
            leftIndex++
        }  else {
            result = result + nums[rightIndex]
            rightIndex = rightIndex +1

        }
    }
    return 0 || min
};

（读错题了，最开始以为是等于，原来是大于等于。不过代码是自己想到的，好耶！）

59 螺旋矩阵

重点：搞清楚边界问题 对于每一条边AB,判断坐标和循环是使用的 [a,b),[b,c)的坐标，然后通过四条边，每圈每个元素的赋值

/**
 * @param {number} n
 * @return {number[][]}
 */
var generateMatrix = function(n) {
    let startX = 0;
    let startY = 0;
    let loop = 1; //循环圈数
    let count = 1;
 
    let martrix =  new Array(n).fill(0).map(() => new Array(n).fill(0));
    const maxLoop = Math.floor(n/2)
    while(loop <= maxLoop){
        let j = startX
        let i = startY
        // 最开始算的长度 ，是 n - 2*(loop -1)，但是这个不算长度啊，是坐标
        const lineLen = n-loop
        for(;j < lineLen; j++){
            martrix[i][j] = count;
            count++
        }
        for(;i <lineLen  ; i++){
            martrix[i][j] = count;
            count++
        }
        for(;j > startX; j--){
            martrix[i][j] = count;
            count++
        }
        for(;i > startY; i--){
            martrix[i][j] = count;
            count++
        }
        startX++;
        startY++;
        loop++;
    }
    if(n%2 === 1){
        martrix[maxLoop][maxLoop] = n*n
    }
    return martrix
};

总结备注：做这种题要画图，想清楚坐标对应的点，一级每次的起始条件 坐标！！！一定记住是按坐标往下推导，不要想到长度上去（因为坐标是统一的度量衡）