矩阵打印--螺旋状-在线编程-K6K4.com

从矩阵的第一个元素A[0][0] 开始，顺时针遍历矩阵的最外层元素,然后从A[1][1]遍历矩阵第二层元素，以此类推，直到遍历完所有的矩阵元素。将结果按遍历顺序放在数组中返回。
提示：矩阵不一定是方正

输入、输出描述

输入：

A:待遍历的矩阵
n:矩阵A的行数
m:矩阵A的列数

输出：

按螺旋状遍历矩阵的结果

Example

输入：

A:
11,12,13,14,15
16,17,18,19,20
21,22,23,24,25
26,27,28,29,30
31,32,33,34,35
n:5, m:5

输出：

11,12,13,14,15,20,25,30,35,34,33,32,31,26,21,16,17,18,19,24,29,28,27,22,23

修改

固定四个顶点，按顺序打印上边、右边、下边、左边，需要特别注意已经遍历过的顶点，使用一个数组记录已经遍历过的点。

代码：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        int[][] x = new int[][]{
                new int[]{11, 12, 13, 14, 15},
                new int[]{16, 17, 18, 19, 20},
                new int[]{21, 22, 23, 24, 25},
                new int[]{26, 27, 28, 29, 30},
                new int[]{31, 32, 33, 34, 35},
        };

        int[] result = solution(x, 5, 5); 

        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < result.length; i++) {
            sb.append(result[i] + ",");
        }
        String str = sb.toString();
        if (str.endsWith(",")) {
            str = str.substring(0, str.length() - 1);
        }

        System.out.println(sb);
        //输出：11,12,13,14,15,20,25,30,35,34,33,32,31,26,21,16,17,18,19,24,29,28,27,22,23

    }

    public static int[] solution(int[][] A, int n, int m) {

        boolean[][] visited = new boolean[n][m];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                visited[i][j] = false;

        int left = 0;
        int right = m - 1;
        int up = 0;
        int down = n - 1;

        int index = 0;
        int len = n * m;
        int[] result = new int[len];
        int x, y;
        while (index < len) {

            //从左上角开始，从左到右打印
            x = left;
            y = up;
            for (; x <= right && !visited[y][x]; x++) {
                result[index++] = A[y][x];
                visited[y][x] = true;

            }

            //从右上角（往下移一个元素）开始，从上往下打印
            x = right;
            y = up + 1;
            for (; y <= down && !visited[y][x]; y++) {
                result[index++] = A[y][x];
                visited[y][x] = true;
            }

            //从右下角（往左移一个元素）开始，从右往左打印
            x = right - 1;
            y = down;
            for (; x >= left && !visited[y][x]; x--) {
                result[index++] = A[y][x];
                visited[y][x] = true;
            }

            //从左下角（往上移一个元素）开始，从下往上打印
            x = left;
            y = down - 1;
            for (; y >= up && !visited[y][x]; y--) {
                result[index++] = A[y][x];
                visited[y][x] = true;
            }

            left++;
            up++;
            right--;
            down--;

        }

        return result;
    }
}