顺时针打印矩阵

阅读数: 8次 Nov 1 2020

题目描述

输一个矩阵，按照从外向里一顺时针的顺序依次打印出每一个数字，例如，如果输入如下4×4的矩阵：

1 2 3 4

5 6 7 8

9 10 11 12

13 14 15 16

则依次打印出的数字为：

1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10.

输入

[[1,2],[3,4]]

输出

[1,2,4,3]

题解

定义四个变量分别代表范围大小：up、down、left、right

第一步：向右走存入整行的值，以left、right作为行的左右边界，当存入之后，将上边界+1，表示第一行已经存入了，同时判断是否超过了下边界。

第二步：右侧向下遍历整列的值，以up、down作为列的上下边界，当存入之后，将右边界-1，表示最右侧的边界已经存入，同时判断是否超过了左边界。

第三步：下边界向左遍历整行的值，以rigth、left作为右左边界，当存入之后，将下边界-1，表示最下侧的边界已经存入，同时判断是否超过了上边界。

第四步：左边界向上遍历整列的值，以down、up作为下上边界，当存入之后，将左边界+1，表示最左侧的边界已经存入，同时判断是否超过了右边界。

复杂度

时间复杂度：O(n)

空间复杂度：O(1)

import java.util.*; //键盘扫描类

public class Solution {

    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        if (matrix == null) return null;
        int up = 0;
        int down = matrix.length-1;
        int left = 0;
        int right = matrix[0].length-1;
        while (true) {
            for (int i = left;i <= right; ++i) {
                arrayList.add(matrix[up][i]);
            }
            if ((++up) > down) {
                break;
            }
            for (int i = up; i <= down; ++i) {
                arrayList.add(matrix[i][right]);
            }
            if ((--right) < left) {
                break;
            }
            for (int i = right; i >= left; --i) {
                arrayList.add(matrix[down][i]);
            }
            if ((--down) < up) {
                break;
            }
            for (int i = down; i >= up; --i) {
                arrayList.add(matrix[i][left]);
            }
            if ((++left) > right) {
                break;
            }
        }
        return arrayList;
    }

    public static void main(String arg[]) {
        Scanner input = new Scanner(System.in);
        int row = input.nextInt();
        int col = input.nextInt();
        int [][] arr = new int[row][col];
        for(int i = 0; i < row; ++i) {
//            String str = input.next();
            for (int j = 0; j < col; ++j) {
                arr[i][j] = input.nextInt();
            }
        }

        for (int i = 0; i < arr.length; ++i) {
            for (int j = 0; j < arr[0].length; ++j) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.print("\n");
        }

        Solution solution = new Solution();
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList = solution.printMatrix(arr);
        for (int i = 0; i < arrayList.size(); ++i) {
            System.out.print(arrayList.get(i) + " ");
        }
    }

}

还有一种简单的方法(python)

将矩阵的第一行截取出来。
判断截取之后是否还存在行数，若不存在，结束循环。
将矩阵向左转置，即向左旋转90度。
重复1步骤

# _*_ coding:utf-8 _*_
class Solution:
    def printMatrix(self, matrix):
        res = []
        while True:
            res.extend(matrix[0])
            if len(matrix) > 1:
                matrix = matrix[1::]
            else:
                break
            matrix = [ [row[i] for row in matrix] for i in range(len(matrix[0])-1, -1, -1)]  # 矩阵装置，向左转90度
        return res

while True:
    info = list(map(int, input().split(" ")))
    arr = [[0] * info[1]] * info[0]

    for i in range(info[0]):
        arr[i] = list(map(int, input().split(" ")))

    # arr = [[row[i] for row in arr] for i in range(len(arr[0]) - 1, -1, -1)]
    # print(arr)
    print(Solution().printMatrix(arr))

Integer 类和 int 的区别

Integer 是 int 包装类，int 是八大基本数据类型之一(byte,char,short,int,long,float,double,boolean)
Integer 是类，默认值是null，int是基本数据类型，默认值是0；
Integer 表示的是对象，用一个引用指向这个对象，而int是基本数据类型，直接储存数据。

Integer的自动拆箱和装箱

自动装箱

一般创建一个类的时候是通过关键字new，比如：
1
Object obj = new Object();
但是对于Integer类，可以这样：
1
Integer a = 128;
这是因为：通过反编译工具可以看到，生成的class文件是：
1
Integer a = Integer.valueOf(128);
这就是基本数据类型的自动装箱，128是基本数据类型，然后被解析成Integer类。
自动拆箱

将Integer类表示的数据赋值给基本数据类型int，就执行了自动拆箱。
1
2
Integer a = new Integer(128);
int m = a;
反编译生成的class文件：
1
2
Integer a = new Integer(128);
int m = a.intValue();
简单的说：自动装箱就是Integer.valueOf(int i)；自动拆箱就是i.intValue()；

Arrays，list，Arraylist 的区别

List是接口，ArrayList是用一个数组实现的List类。

ArrayList是自动扩容的Arrays，有add(),remove()方法。

ArrayList相比于Arrays少了[]操作，而是利用get(i)配合索引值来取值。

ArrayList不能写成ArrayList

Array(数组)是基于索引(index)的数据结构，使用索引在数组中搜索和读取数据是很快的。

获取数据的时间复杂度是O(1)，但是要删除数据开销很大，要重排数组中的所有数据。

List是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式。

List是一个接口，不能写成：

1	List<Integer> list = new List<Integer>(); // 错误

ArrayList可以看成是能够自动增长容量的数组。