代码随想录算法训练营第二天|977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II

海棠依旧€

已于 2022-09-22 18:42:22 修改

阅读量4k

点赞数

文章标签：算法 leetcode 数据结构 java

于 2022-09-22 16:44:24 首次发布

本文链接：https://blog.csdn.net/weixin_44565532/article/details/126984809

版权

一、 977:有序数组的平方：力扣

思路：1、最直接的方法是先将所有数组元素的平方数放入一个新的数组中，然后再进行排序。

2、使用双指针的思路，定义 left 和 right 两个指针分别指向数组两端，分别比较两端的平方数，将较大的存入新数组的末尾，数组的index减一，左右指针进行相应变化。

class Solution {
    public int[] sortedSquares(int[] nums) {
        /*垃圾解法
        int length = nums.length;
        int[] array = new int[length];
        for(int i = 0; i < nums.length; i++){
            array[i] = nums[i] * nums[i];
        }
        Arrays.sort(array);
        return array;
        */
        //左右指针依此比较大小，按照顺序放入新的数组之中
        int left = 0;
        int right = nums.length - 1;
        int[] result = new int[nums.length];
        int index = result.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;
    }
}

二、209:长度最小的子数组

209:长度最小的子数组

思路：1、暴力解法：两层for循环遍历，当sum >= target时计算子数组长度并与result比较，取最小的更新result。提交但是超出了时间限制。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int result = Integer.MAX_VALUE;
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = 0;
            for (int j = i; j < nums.length; j++) {
                sum += nums[j];
                if (sum >= target) {
                    result = Math.min(j-i+1, result);
                    break;
                }
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

2、滑动窗口：所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环完成了一个不断搜索区间的过程。

只用一个for循环，那么这个循环的索引，一定是表示滑动窗口的终止位置。滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动，所以叫做滑动窗口更适合一些。

for循环滑动窗口的终止位置，不断更新窗口的起始位置，因为窗口里面有多个符合大于target的窗口，比如第一个元素如果是负数，去掉之后还是大于target，所以循环里面的判断条件使用while而不使用if。

不要以为for里放一个while就以为是O(n^2)，主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= target) {
                result = Math.min(right-left+1, result);
                sum -= nums[left++];//这里体现滑动窗口的精髓，不断变更i(子序列的起始位置)
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

三、904.水果成篮

力扣

也是滑动窗口的题目。

class Solution {
    public int totalFruit(int[] fruits) {
        // 我们发现形成窗口大小其实是固定的(两个篮子==果子种类)
        // 键为果子类型，值为果子数量
        Map<Integer, Integer> map=new HashMap<>();
        int left = 0;
        int result = 0;
        for(int right = 0; right < fruits.length; right++) {
            map.put(fruits[right], map.getOrDefault(fruits[right], 0) + 1);
            // 窗口果子种类超过两种果子了，广快弄掉一个种类的果子
            while(map.size() > 2){
                map.put(fruits[left], map.get(fruits[left]) - 1);
                if(map.get(fruits[left]) == 0){
                    map.remove(fruits[left]);
                }
                left++;
            }
            result = Math.max(result, right - left + 1);
        }
        return result;
    }
}

四、螺旋矩阵总结

力扣：59螺旋矩阵II

思路：自己看着题目还是不能独立完整的写出来，看一下讲解。

循环不变量，遍历四条路径时都保持左闭右开的原则，循环的次数loop < n / 2; 定义全局变量i，j，用来记录访问元素的位置，此题行和列相等，算特殊的矩阵。

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];
        int loop = 0;
        int count = 1;//填充的数字
        int start = 0;
        int i, j;
        while (loop++ < n/2) {
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {
                res[start][j] = count++;
            }
            // 模拟右侧从上到下
            for (i = start; i < n - loop; i++) {
                res[i][j] = count++;
            }
            // 模拟下侧从右到左
            for (; j >= loop; j--) { //i,j 目前都等于n - loop
                res[i][j] = count++;
            }
            for (; i >= loop; i--) {
                res[i][j] = count++;
            }
            start++;
        }
        if(n %2 == 1) {
            res[start][start] = count;
        }
        return res;
    }
}

力扣：剑指offer29，顺指针打印螺旋矩阵

力扣：53.螺旋矩阵

loop的计算：本题的loop计算与59.螺旋矩阵II算法略微差异，因为存在rows和columns两个维度，可自行分析，loop只能取min(rows, columns)，例如rows = 5, columns = 7，那loop = 5 / 2 = 2；
mid的计算及填充： 1、同样的原理，本题的mid计算也存在上述差异； 2、如果min(rows, columns)为偶数，则不需要在最后单独考虑矩阵最中间位置的赋值如果min(rows, columns)为奇数，则矩阵最中间位置不只是[mid][mid],而是会留下来一个特殊的中间行或者中间列，具体是中间行还是中间列，要看rows和columns的大小，如果rows > columns,则是中间列，相反，则是中间行。

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        int row = matrix.length;
        if (row == 0) return new int[0];
        int col = matrix[0].length;
        int i,j;
        int startx = 0;
        int starty = 0;
        int loop = Math.min(row, col) / 2;
        int mid = Math.min(row, col) / 2;
        int offset = 1;
        int[] res = new int[col * row];
        int index = 0;
        while (loop-- > 0) {
            i = startx;
            j = starty;
            for (j = starty; j < starty + col - offset; j++) {
                res[index++] = matrix[starty][j];
            }
            for (i = startx; i < startx + row - offset; i++) {
                res[index++] = matrix[i][j];
            }
            for (; j > starty; j--) {
                res[index++] = matrix[i][j];
            }
         
            for (; i > startx; i--) {
                res[index++] = matrix[i][j];
            }
            startx++;
            starty++;
            offset += 2;
        }
        if ((Math.min(row, col)%2) != 0 ) {
            if (col > row) {
                for (j = mid; j < mid + col - row + 1; j++) {
                    res[index++] = matrix[mid][j];
                }
            }else {
                for(i = mid; i < mid + row - col + 1; i++) {
                    res[index++] = matrix[i][mid];
                }
            }
        }
        return res;
    }
}

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        int row = matrix.length;
        int col = matrix[0].length;
        int i,j;
        int startx = 0;
        int starty = 0;
        int loop = Math.min(row, col) / 2;
        int mid = Math.min(row, col) / 2;
        int offset = 1;
        while (loop-- > 0) {
            i = startx;
            j = starty;
            for (j = starty; j < starty + col - offset; j++) {
                result.add(matrix[starty][j]);
            }
            for (i = startx; i < startx + row - offset; i++) {
                result.add(matrix[i][j]);
            }
            for (; j > starty; j--) {
                result.add(matrix[i][j]);
            }
         
            for (; i > startx; i--) {
                result.add(matrix[i][j]);
            }
            startx++;
            starty++;
            offset += 2;
        }
        if ((Math.min(row, col)%2) != 0 ) {
            if (col > row) {
                for (j = mid; j < mid + col - row + 1; j++) {
                    result.add(matrix[mid][j]);
                }
            }else {
                for(i = mid; i < mid + row - col + 1; i++) {
                    result.add(matrix[i][mid]);
                }
            }
        }
        return result;
    }
}