代码随想录Day02 | Leetcode 977 有序数组的平方 、Leetcode 209 长度最小的子数组、Leetcode 59 螺旋矩阵II

977.有序数组的平方

import java.util.Arrays;

class Solution {
    public int[] sortedSquares(int[] nums) {
        int flag = 1;
        if (nums[0] > 0 || nums[nums.length - 1] < 0) {
            flag = 0;
        }
        if (nums[nums.length - 1] < 0) {
            for (int i = 0, j = nums.length - 1; i < j; i++, j--) {
                swap(nums, i, j);
            }
        }
        //找到0分界
        int divde = 0;
        if (flag == 1) {
            for (int i = 0; i < nums.length - 1; i++) {
                if (nums[i] < 0 && nums[i + 1] >= 0) {
                    divde = i;
                    //0分界注意是否加一
                    if (nums[i + 1] == 0) {
                        divde = i + 1;
                    }
                    // System.out.println("divde = " + divde);
                    break;
                }
            }
        }
        // for (int i = 0; i < nums.length; i++) {
        //     System.out.println("i = " + nums[i]);
        // }
        int begin = divde;
        int end = divde + 1;
        int[] res = new int[nums.length];
        int k = 0;
        while (begin >= 0 || end < nums.length) {
            int a = begin >= 0 ? Math.abs(nums[begin]) * Math.abs(nums[begin]) : Integer.MAX_VALUE;
            int b = end < nums.length ? Math.abs(nums[end]) * Math.abs(nums[end]) : Integer.MAX_VALUE;

            // System.out.println("begin = " + begin);
            // System.out.println("end = " + end);
            // System.out.println("k = " + k);
            // System.out.println("a = " + a);
            // System.out.println("b = " + b);

            //把begin<0和end>nums.length排除
            if (a < b && begin >= 0) {
                res[k++] = a;
                begin--;
            } else if (b <= a && end < nums.length) {
                end++;
                res[k++] = b;
            }

        }
        return res;
    }

    public void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

209.长度最小的子数组

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int max = 0;
        int sum = 0;
        int width = 0;
        int res = Integer.MAX_VALUE;
        int left = 0;

        for (int i = 0; i < nums.length; i++) {
            width++;
            sum += nums[i];
            if (sum >= target) {
                //不需要判断nums[i]是否添加，因为i总是向后移动，
                // 所以一定会添加，即使sum没有增加
//                if (sum - nums[left] + nums[i] >= target) {
//                    sum -= nums[left];
//                    left++;
//                    sum += nums[i];
//                }
                while (sum - nums[left] >= target) {
                    sum -= nums[left];
                    left++;
                    width--;
                }
                res = Math.min(res, width);

            }
        }
        res = Math.min(res, width);

        if (sum >= target && res != Integer.MAX_VALUE) {
            return res;
        } else {
            return 0;
        }
    }
}

59.螺旋矩阵II

import java.util.Arrays;

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] nums = new int[n][n];
        //左上角
        int[] leftUpCorner = {0, 0};
        //左下角
        int[] leftDownCorner = {0, n - 1};
        //右上角
        int[] rightUpCorner = {n - 1, 0};
        //右下角
        int[] rightDownCorner = {n - 1, n - 1};
        //0右 1下 2左 3上
        int direction = 0;
        int k = 1;
        while (k < n * n + 1) {
            if (direction == 0) {
                //判断n为奇数时候，会卡住
                if (Arrays.equals(leftUpCorner, leftDownCorner) &&
                        Arrays.equals(leftDownCorner, rightUpCorner) &&
                        Arrays.equals(rightUpCorner, rightDownCorner) && n % 2 != 0) {
                    nums[n / 2][n / 2] = k;
                    break;
                }
                k = goRight(nums, leftUpCorner, leftDownCorner, rightUpCorner, rightDownCorner, k);
                direction = 1;
            } else if (direction == 1) {
                k = goDown(nums, leftUpCorner, leftDownCorner, rightUpCorner, rightDownCorner, k);
                direction = 2;
            } else if (direction == 2) {
                k = goLeft(nums, leftUpCorner, leftDownCorner, rightUpCorner, rightDownCorner, k);
                direction = 3;
            } else if (direction == 3) {
                k = goUp(nums, leftUpCorner, leftDownCorner, rightUpCorner, rightDownCorner, k);
                direction = 0;
                //遍历完一圈之后再缩圈，不要每次都移动完之后缩圈
                //        leftUpCorner[0]++;
                //        leftUpCorner[1]++;
                //会导致错误
                leftUpCorner[0]++;
                leftUpCorner[1]++;
                rightUpCorner[0]--;
                rightUpCorner[1]++;
                rightDownCorner[0]--;
                rightDownCorner[1]--;
                leftDownCorner[0]++;
                leftDownCorner[1]--;
            }

        }


        return nums;
    }


    public int goRight(int[][] nums, int[] leftUpCorner, int[] leftDownCorner, int[] rightUpCorner,
                       int[] rightDownCorner, int k) {
        int begin = leftUpCorner[0];
        int end = rightUpCorner[0];
        int row = leftUpCorner[1];

        for (int j = begin; j < end; j++) {
            nums[row][j] = k++;
        }
//        leftUpCorner[0]++;
//        leftUpCorner[1]++;
        return k;
    }


    public int goDown(int[][] nums, int[] leftUpCorner, int[] leftDownCorner, int[] rightUpCorner,
                      int[] rightDownCorner, int k) {
        int begin = rightUpCorner[1];
        int end = rightDownCorner[1];
        int clunm = rightUpCorner[0];
        for (int i = begin; i < end; i++) {
            nums[i][clunm] = k++;
        }
//        rightUpCorner[0]--;
//        rightUpCorner[1]++;
        return k;
    }


    public int goLeft(int[][] nums, int[] leftUpCorner, int[] leftDownCorner, int[] rightUpCorner,
                      int[] rightDownCorner, int k) {
        int begin = leftDownCorner[0];
        int end = rightDownCorner[0];
        int row = rightDownCorner[1];
        for (int j = end; j > begin; j--) {
            nums[row][j] = k++;
        }
//        rightDownCorner[0]--;
//        rightDownCorner[1]--;
        return k;
    }


    public int goUp(int[][] nums, int[] leftUpCorner, int[] leftDownCorner, int[] rightUpCorner,
                    int[] rightDownCorner, int k) {
        int end = leftDownCorner[1];
        int begin = leftUpCorner[1];
        int clunm = leftDownCorner[0];
        for (int i = end; i > begin; i--) {
            nums[i][clunm] = k++;
        }
//        leftDownCorner[0]++;
//        leftDownCorner[1]--;
        return k;
    }

    
}