螺旋矩阵的运用

螺旋矩阵的运用

螺旋矩阵，顾名思义，是一个旋转的矩阵，且经常按顺时针旋转

遇到这类问题，最重要的是知道哪些是不变量，确定哪一行中的哪些数据要输出，哪一列中的哪些数据要输出。最好的解决办法就是按左闭右开的形式展开。

1.螺旋矩阵II

力扣：59. 螺旋矩阵 II - 力扣（Leetcode）

思路

1.创建一个n*n的二维数组

2.因为这是一个n的平方的二维数组，所以说这个矩阵永远是个正方形

3.每次循环的开始的位置都是[0,0],[1,1],[2,2]以此类推，所以我们定义一个start的变量表示循环开始的位置

4.循环次数是n/2，当n是奇数时最后处理空出来的那个位置

5.上侧从左到右：for (j = start; j < n - loop; j++)

6.右侧从上到下：for (i = start; i < n - loop; i++)

7.下侧从右到左：for (; j >= loop; j–)

8.左侧从下到上：for (; i >= loop; i–)

9.最后处理n为奇数的

代码实现

package com.algo.array;

public class Algo59 {
    public int[][] generateMatrix(int n) {
        /**
         * 该算法的时间复杂度为 O(n^2)，其中 n 是生成的二维数组的边长。
         * 因为需要遍历整个二维数组，并且每个格子都要填入一个数字，所以时间复杂度是 O(n^2)。
         * 该算法的空间复杂度为 O(n^2)
         * 因为需要创建一个 n × n 的二维数组来存储结果，所以空间复杂度是 O(n^2)。
         */
        int[][] nums = new int[n][n];//创建一个螺旋二维数组
        int start = 0;  // 每次循环的开始点(start, start)
        int loop = 0;  // 控制循环次数
        int count = 1;  // 定义填充数字
        int i, j;
        while (loop++ < n / 2) {
            //模拟上侧从左到右
            for (j = start; j < n - loop; j++) {
                nums[start][j] = count++;
            }
            //模拟右侧从上到下
            for (i = start; i < n - loop; i++) {
                nums[i][j] = count++;
            }
            //模拟下侧从右到左
            for (; j >= loop; j--) {
                nums[i][j] = count++;
            }
            //模拟左侧从下到上
            for (; i >= loop; i--) {
                nums[i][j] = count++;
            }
            start++;
        }
        if (n % 2 == 1) {
            nums[start][start] = count;
        }
        return nums;
    }
}

2.螺旋矩阵

力扣：54. 螺旋矩阵 - 力扣（Leetcode）

思路

1.先参考螺旋矩阵II的思想，只不过每次遍历元素就将其加入到链表中

2.跳出循环后有四种情况

​ 1）如果链表的长度等于数组中元素的个数，表明这是一个正方形且为偶数的矩阵，可以直接返回

​ 2）如果这是一个正方形且为奇数的矩阵，那么就将矩阵最中间的值添加到链表中就可以返回

​ 3）如果这是一个横轴大于纵轴或纵轴大于横轴的矩阵，那么就需要特殊处理

​ 4）不管是哪一种长方形矩阵，跳出循环后再次赋值，都是循环较长的轴减去较小的轴的次数

3.最后返回链表

代码实现

package com.algo.array;

import java.util.ArrayList;
import java.util.List;

public class Algo54 {
    public List<Integer> spiralOrder(int[][] matrix) {
        /**
         * 时间复杂度分析：
         *
         * 该算法的时间复杂度为 O(m*n)，其中 m 为矩阵的行数，n 为矩阵的列数。在最坏情况下，需要遍历整个矩阵中的所有元素。
         *
         * 空间复杂度分析：
         *
         * 该算法的空间复杂度为 O(m*n)，其中 m 为矩阵的行数，n 为矩阵的列数。主要是由于需要用一个列表来存储遍历得到的元素。
         */
        List<Integer> list =new ArrayList<>();
        //如果这个二维数组只有横行，那么直接按顺序添加到链表里
        if(matrix.length==1){
            for (int i = 0; i < matrix[0].length; i++) {
                list.add(matrix[0][i]);
            }
            return list;
        }
        //如果这个二维数组只有纵行，那么直接按顺序添加到链表里
        if(matrix[0].length==1){
            for (int i = 0; i < matrix.length; i++) {
                list.add(matrix[i][0]);
            }
            return list;
        }
        int loop = 0;//控制循环次数
        int startx = 0;//记录每次循环的时候横轴位置
        int starty = 0;//记录每次循环的时候纵轴位置
        int i,j;
        int x = matrix[0].length;//横轴有多少个元素
        int y = matrix.length;//纵轴有多少个元素
        int n = Math.min(x,y);//循环次数的多少取决于较小的边
        while (loop++<n/2){
            //上侧从左到右开始加入
            for(j=startx;j<x-loop;j++){
                list.add(matrix[startx][j]);
            }
            //右侧从上到下开始加入
            for(i=starty;i<y-loop;i++){
                list.add(matrix[i][j]);
            }
            //下侧从右到左开始加入
            for(;j>=loop;j--){
                list.add(matrix[i][j]);
            }
            //左侧从下到上加入
            for(;i>=loop;i--){
                list.add(matrix[i][j]);
            }
            startx++;//添加横轴初始位置+1
            starty++;//添加纵轴初始位置+1
        }
        //如果链表元素个数等于数组元素个数，那么代表全部添加完毕，直接返回
        if(list.size()==x*y){
            return list;
        }
        //当是奇数正方形矩阵时，手动给链表添加链表最后一个元素
        if(x==y&y%2==1){
            list.add(matrix[startx][starty]);
        }else if(x>y){//如果横轴元素大于纵轴元素时
            //从初始位置添加横轴多余的元素
            for (int k = 0; k <=x-y; k++) {
                list.add(matrix[startx][starty]);
                starty++;
            }
        }else{//如果纵轴元素大于横轴元素时
            //从初始位置添加横轴多余的元素
            for (int k = 0; k <=y-x; k++) {
                list.add(matrix[startx][starty]);
                startx++;
            }
        }
        return list;
    }
}

3.顺时针打印矩阵

力扣：剑指 Offer 29. 顺时针打印矩阵 - 力扣（Leetcode）

思路

1.参考螺旋矩阵

2.当你做过螺旋矩阵后发现这道题的原理和上一道原理差不多，一个是加入链表，一个是加入数组

3.这道题数组就要考虑数组足够大时，内存中没有那么多连续存储空间，当没有那么多连续存储空间时就会报异常

4.对异常进行处理

代码实现

package com.algo.array;

public class Algooffer29 {
    public int[] spiralOrder(int[][] matrix) {
        //当没有元素时  直接返回
        if (matrix.length == 0) {
            return new int[0];
        }
        int[] nums = new int[matrix.length * matrix[0].length];
        int loop = 0;//控制循环
        int x = matrix[0].length;//横轴元素个数
        int y = matrix.length;//纵轴元素个数
        int startx = 0;//横轴初始位置
        int starty = 0;//纵轴初始位置
        int n = Math.min(x, y);//循环次数取决于横或纵轴的元素个数
        int i, j;
        int count = 0;//控制添加到数组中的位置
        while (loop++ < n / 2) {
            //上侧从左到右
            for (j = startx; j < x - loop; j++) {
                nums[count++] = matrix[startx][j];
            }
            //右侧从上到下
            for (i = starty; i < y - loop; i++) {
                nums[count++] = matrix[i][j];
            }
            //下侧从右到左
            for (; j >= loop; j--) {
                nums[count++] = matrix[i][j];
            }
            //右侧从下到上
            for (; i >= loop; i--) {
                nums[count++] = matrix[i][j];
            }
            startx++;
            starty++;
        }
        //如果是正方形偶数矩阵时  直接返回
        if (nums[nums.length - 1] != 0) {
            return nums;
        }
        //当是奇数正方形矩阵时，手动给链表添加链表最后一个元素
        if (x == y & y % 2 == 1) {
            nums[count] = matrix[startx][starty];
        }
        try {
            if (x > y) {//如果横轴元素大于纵轴元素时
                //从初始位置添加横轴多余的元素
                for (int k = 0; k <= x - y; k++) {
                    nums[count++] = matrix[startx][starty];
                    starty++;
                }
            } else {//如果纵轴元素大于横轴元素时
                //从初始位置添加横轴多余的元素

                for (int k = 0; k <= y - x; k++) {
                    nums[count++] = matrix[startx][starty];
                    startx++;
                }

            }

        }catch (Exception e) {
            return nums;
        }
        return nums;
    }
}