day2 有序数组的平方|长度最小的子数组|螺旋矩阵II

1.有序数组的平方 leetcode 977

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

题目中数组是按升序排序，所以平方后，最大值要么在左边，要么在右边

所以定义两个指针，一个在最左边，一个在最右边，谁大就把谁先加入数组中,加入后，j往左边挪，i往右边挪，因为输出数组是按从小到大排序，所以最大的数，放在数组的最后一位，放完后，再放倒数第二位，以此类推

var sortedSquares = function (nums) {
    let arr = new Array(nums.length).fill(0);
    let k = nums.length - 1;
    for (let i = 0, j = nums.length - 1; i <= j;) {
        if (Math.pow(nums[i], 2) > Math.pow(nums[j], 2)) {
            arr[k] = Math.pow(nums[i], 2);
            k--;
            i++
        } else {
            arr[k] = Math.pow(nums[j], 2);
            k--;
            j--
        }
    }
    return arr
};

2.长度最小的子数组leetcode 209

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3]是该条件下的长度最小的子数组。
输入：target = 4, nums = [1,4,4]
输出：1

此题使用滑动窗口，窗口不断滑动，直到符合题目条件。定义窗口两边i，j.j向后滑动，并且累加j的和，如果和大于等于target，则证明符合题意，此时挪动i,缩小窗口，总数要减去nums[i],因为每次累加值是窗口内的元素之和。

var minSubArrayLen = function (target, nums) {
  let i = 0;
  let sum = 0;
  let min = Infinity;
  for (let j = 0; j < nums.length; j++) {
    sum += nums[j];
    // 此时使用while，不能使用if，如果用if，执行到这里就停了
    while (sum >= target) {
      // 去掉一个nums[i],看总数是否还符合大于等于的条件,不断缩小窗口寻找最小值
      sum -= nums[i]
      min = Math.min(min, j - i + 1)
      i++;
    }
  }
  return min === Infinity ? 0 : min
}

3.螺旋矩阵II leetcode 59

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]] 

这道题有点晕，不知道下次能不能独自做出来

这题主要是要确定每一圈的边界，如果确定了，每一行都要按这个边界判断走，不能随意变动

var generateMatrix = function (n) {
     // 起始位置，因为每圈的起始位置都不一样，所以定义为变量
    let startX = 0;
    let startY = 0;
    let offset = 1;
    // 计数
    let count = 1;
    // 中间值
    let mid = Math.floor(n / 2);
    // 看循环几圈
    let loop = Math.floor(n / 2);
    // 初始化一个二维数组，每个值置为0;
    let res = new Array(n).fill(0).map(() => new Array(n).fill(0))
    while (loop--) {
        let row = startX;
        let col = startY;
        //从左往右添加值 res[0][0] res[0][1]
        for (; col < startY + n - offset; col++) {
            res[row][col] = count++
        }
        //从上到下添加值 res[0][2] res[1][2]
        for (; row < startX + n - offset; row++) {
            res[row][col] = count++
        }
        // 从左往右添加值 res[2][2] res[2][1]
        for (; col > startY; col--) {
            res[row][col] = count++
        }
        // 从下往上添加值 res[2][0] res[1][0]
        for (; row > startX; row--) {
            res[row][col] = count++
        }
        // 更新圈数
        startX++;
        startY++;
        // 更新offset
        offset += 2;
    }

    // 如果是奇数，更新最中间的值
    if (n % 2 === 1) {
        res[mid][mid] = count
    }
    return res

}