java顺时针、逆时针打印矩阵

题目要求：

顺时针打印一个数组，比如输入3，打印出：

首先我们来分析一下这个数组，如下图所示,数组的是沿着顺时针的方向按照数字递增的方式增加的，我们一般是使用for嵌套来构造这个数组。但这样结构还臃肿了，而且也不好设计。最新开始也是这样想的，但发现这样的方式不是最优雅的！！

比如楼主看到的一个案例。

虽然博主写得很详细，说实在看着头就痛。为了能写得更优雅，楼主在网上找到了一个方案，然后理解后修改了一下。自我感觉这种方案比较好理解，也不要一个一个的嵌入for。

分析：数组每次都会依次填入，但每次到边界时就自动换方向。第一次向右，到边界时马上变为向下，到了下边界然后再向左，同理到了左边界再向上。所以我们可以定义一个方向的enum。然后在根据每次的转换变方向。源码如下：

import java.util.*; 
public class SnakeMatrix{ 
/** 
* 定义矩阵的阶数 
*/ 
private int n;

//填充矩阵的值
private int k = 1;

private int[][] data;
/**
 *定义矩阵移动的方向
 */
public enum Direction{  
    left,right,up,down,  
}  

SnakeMatrix(int n){
    this.n = n;
    data = new int[n][n];
}

public void clockwisePrintMatrix(){
    //定义行数
    int rowLen = data.length;

    //定义列数
    int columnLen = data.length;

    //移动方向
    Direction direction=Direction.right; 

    //定义上边界
    int upBound = 0;

    //定义下边界
    int downBound = rowLen - 1;

    //定义左边界
    int leftBound = 0;

    //定义右边界
    int rightBound = columnLen -1;

    //矩阵当前行数
    int row = 0;

    //矩阵当前列数
    int column = 0;

    while(true){
        data[row][column] = k++;
        if(upBound==downBound&&leftBound==rightBound){ 
          //  System.out.println(" upBound :"+upBound +" downBound :"+downBound+" leftBound :"+leftBound +" rightBound :"+rightBound); 
            break;  
        } 
      switch (direction){  
        case right:  
            if(column<rightBound){  
                ++column;  
            }else{  
                ++row;  
                direction=Direction.down;  
                ++upBound;  
            }  
            break;  
        case down:  
            if(row<downBound){  
                ++row;  
            }else{  
                --column;  
                direction=Direction.left;  
                --rightBound;  
            }  
            break;  
        case up:  
            if(row>upBound){  
                --row;  
            }else{  
                ++column;  
                direction=Direction.right;  
                ++leftBound;  
            }  
            break;  
        case left:  
            if(column>leftBound){  
                --column;  
            }else{  
                --row;  
                direction=Direction.up;  
                --downBound;  
            }  
            break;  
        default:break;  
        } 

    }

    for (int i= 0;i<n ; i++) {
        for (int j = 0; j<n;j++ ) {
            System.out.printf("%2d%s",data[i][j]," ");
        }
        System.out.println();

    }
}


public void anticlockwisePrintMatrix(){

    int rowLen = data.length;

    int columnLen = data.length;

    int leftBound = 0;

    int rightBound = columnLen - 1;

    int upBound = 0;

    int downBound =rowLen - 1;

    int row = 0;

    int column = 0;

    Direction direction = Direction.down;

    while(true){

          data[row][column] = k++;

         if(rightBound == leftBound && upBound == downBound){
            break;
         }

      switch(direction){

          case down:
            if(row < downBound){
                row++;                
            }else{
                column++;
                direction = Direction.right;
                leftBound++;
            }
            break;
          case right:
            if(column < rightBound){
                column++;
            }else{
                row--;
                direction = Direction.up;
                downBound--;
            }
            break;
          case up:
             if(row > upBound){
                row--;
             }else{
                direction = Direction.left;
                column--;
                rightBound--;
             }
            break;
          case left:
              if(column > leftBound){
                 column--;
              }else{
                direction = Direction.down;
                row++;
                upBound++;
              }
            break;
            default:break;
      }

}

    for (int i= 0;i<n ; i++) {
        for (int j = 0; j<n;j++ ) {
            System.out.printf("%2d%s",data[i][j]," ");
        }
        System.out.println();       
    }

 
 
1
2
3
4
5
6
7
8
9
10
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入阶数: ");
    int number = scanner.nextInt();
    SnakeMatrix snakeMatrix = new SnakeMatrix(number);
    //snakeMatrix.anticlockwisePrintMatrix();
    snakeMatrix.clockwisePrintMatrix();
}

 
 
1
2
3
4
5
6
7
8
9

}

其中添加了逆时针打印。效果图如下: