1、有序数组的平方

977.有序数组的平方
本题是双指针比较好的应用，考虑到有负数的存在，并且从小到大排序，那么最大的数的平方一定在数组两端，所以让两个指针从两端逐渐往中间靠拢，比较大小之后将较大数的平方插入新数组的末尾

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] result = new int[nums.length];
        //新数组的索引
        int index = nums.length - 1;
        int left = 0;
        int right = nums.length - 1;
        while(left <= right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                
                result[index--] = nums[left] * nums[left];
                left++;
            }
            else {
                result[index--] = nums[right] * nums[right];
                right--;
            }
        }
        return result;
    }
}

2、长度最小的子数组

209.长度最小的子数组
本题使用滑动窗口的方法，也是指定两个指针，分为为窗口的两端，以窗口右边界为循环，当窗口内大于target时，窗口左边界缩小，直到窗口内的值不满足条件，然后移动窗口右边界，进入下一个循环。
要注意sum的计算方法，当移动left时不要忘记减去left对应的值。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int result = nums.length + 1;
        int sum = 0;
        /*
        以窗口右边界为循环，当窗口内大于target时，窗口左边界缩小，直到窗口内
        的值不满足条件，然后移动窗口右边界，进入下一个循环
        */
        for (int right=0; right<nums.length; right++) {
            sum += nums[right];
            while(sum >= target) {
                result = Math.min(result, right-left+1);
                sum -= nums[left++];
            }
        }
        return result == nums.length + 1 ? 0 : result;
    }
}

3、螺旋矩阵II

59.螺旋矩阵II
这道题并没有用到数据结构，主要是考察循环的思想，需要统一对四条边处理的规则，这里采用左闭右开的原则，定义每次循环起始点的横纵坐标，并且利用循环次数loop这个变量进行每次循环的赋值

class Solution {
    public int[][] generateMatrix(int n) {
        int result[][] = new int[n][n];
        //每次循环的起始位置
        int startx = 0;
        int starty = 0;
        //填充的数值
        int count = 1;
        //循环的次数
        int loop = 1;
        //四边填充数据时，统一按照左闭右开的规则
        while (loop <= n/2) {
            //上边从左到右
            for (int j = starty; j < n - loop; j++) {
                result[startx][j] = count++;
            }
            //右边从上到下
            for (int i = startx; i < n - loop; i++) {
                result[i][n-loop] = count++;
            }
            //下边从右到左
            for (int j = n - loop; j > starty; j--) {
                result[n-loop][j] = count++;
            }
            //左边从下到上
            for (int i = n - loop; i > startx; i--) {
                result[i][starty] = count++;
            }
            loop++;
            startx++;
            starty++;
        }
        //单独处理n为奇数时，最后的元素
        if (n % 2 == 1) {
            result[n-loop][n-loop] = count;
        }
        return result;
    }
}