蛇形矩阵的java实现

题目：

计算并输出 nXn 的蛇形矩阵。(n>0)
例如 4X4 的蛇形矩阵如下：
1   3   4  10
2   5   9  11
6   8  12  15
7  13  14  16

类似于前面的输出螺旋矩阵的方法，每一次在数组中填写新的数字都有一个方向，与输出螺旋数组不同的是不是简单的上下左右四个方向，这里涉及到右，下，右上，左下四个方向，针对每步操作都需要想好对应的处理方法，如：

1）向右上位置填写元素的时候可能会碰到行<0或者是列>=N，如果行小于0,那么接下来就需要向右填写元素，列大于等于N，那么很明显接下来就要向下填写元素。

2）向下添加元素时，也会碰到一些情况，例如行>=N了，表示添加到最后一行了，此时需要向右移动，另外在第一列和最后一列向下添加元素情况也不一样，在第一列向下添加元素后，接下来应该向右上添加元素，在最后一列向下添加元素后接下来应该向左下添加元素。

向左下和向右填写元素与这类似。

参加下面的代码（代码来自于http://blog.csdn.net/Mailbomb/archive/2008/07/05/2613736.aspx）

Java代码

1. public static void main(String[] args) { 
2.         /**2、计算并输出nXn的蛇形矩阵。(n>0)
3.         * 例如4X4的蛇形矩阵如下：
4.         * 1  3  4 10
5.                                   * 2  5  9 11
6.                                   * 6  8 12 15
7.                                   * 7 13 14 16
8.          */  
9.         //DOWN UPRIGHT RIGHT LEFTDOWN 
10.         int n=5; 
11.         int[][] data = new int[n][n]; 
12.         int dire; //当前数字的移动方向 
13.         final int UPRIGHT = 0; //上右 
14.         final int DOWN = 1; // 下 
15.         final int LEFTDOWN= 2; //左下 
16.         final int RIGHT = 3;// 右 
17.         dire = DOWN; 
18.         int value = 1; //数组元素的值 
19.         int row = 0; //第一维下标 
20.         int col = 0; //第二维下标 
21.         data[0][0] = 1; //初始化第一个元素  
22.         data[n-1][n-1] = n*n; 
23.         while(value < n * n-1){ 
24.             System.out.print("("+dire+")"); 
25.             switch(dire){ 
26.                 case DOWN://DOWN -UPRIGHT +RIGHT -LEFTDOWN 
27.                     row++; //移动到下一行 
28.                     if(row>=n){ //超过边界 
29.                         row--; //后退 
30.                         dire = RIGHT; 
31.                         continue; //跳过该次循环 
32.                     } 
33.                     else  
34.                     { 
35.                         value++; //数值增加1 
36.                         data[row][col] = value;//赋值 
37.                         if(col==0) {  
38.                             dire = UPRIGHT;  
39.                         } 
40.                         else if(col==n-1){  
41.                             dire = LEFTDOWN;  
42.                         } 
43.                     }  
44.                     break; 
45.                 case UPRIGHT://+DOWN -UPRIGHT +RIGHT LEFTDOWN 
46.                     row--; 
47.                     col++; //移动到上一行，右一列 
48.                     if(col>=n)//超过边界 
49.                     { 
50.                         row++; 
51.                         col--; //后退 
52.                         dire = DOWN; 
53.                         continue; //跳过该次循环 
54.                     } 
55.                     else if(row<0){ //超过边界 
56.                         row++; 
57.                         col--; //后退 
58.                         dire = RIGHT;  
59.                         continue; //跳过该次循环  
60.                     } else { 
61.                         value++; //数值增加1 
62.                         data[row][col] = value;//赋值 
63.                         dire = UPRIGHT; 
64.                     } 
65.                     break; 
66.                 case RIGHT://+DOWN -UPRIGHT RIGHT -LEFTDOWN 
67.                     col++; //移动到右一列 
68.                     if(col>=n){  
69.                         col--; //后退 
70.                         dire = DOWN; 
71.                         continue; //跳过该次循环 
72.                     } 
73.                     else { 
74.                         value++; //数值增加1 
75.                         data[row][col] = value;//赋值 
76.                         if(row==0) {  
77.                             dire = LEFTDOWN;  
78.                         } 
79.                         else if(row==n-1){  
80.                             dire = UPRIGHT;  
81.                         } 
82.                     } 
83.                     break; 
84.                 case LEFTDOWN://+DOWN UPRIGHT +RIGHT -LEFTDOWN 
85.                     row++; 
86.                     col--; //移动到下一行，左一列 
87.                     if(row>=n) { //超过边界 
88.                         row--;col++; //后退 
89.                         dire = RIGHT; 
90.                         continue; //跳过该次循环 
91.                     }else if(col<0)//超过边界 
92.                     { 
93.                         row--;col++; //后退 
94.                         dire = DOWN; 
95.                         continue; //跳过该次循环 
96.                     } 
97.                     else { 
98.                         value++; //数值增加1 
99.                         data[row][col] = value;//赋值 
100.                         dire = LEFTDOWN; 
101.                     } 
102.                     break; 
103.             } 
104.         } 
105.         System.out.println(); 
106.         //输出数组中的元素 
107.         for(int i = 0;i < data.length;i++){ 
108.             for(int j = 0;j < data[i].length;j++){ 
109.                 if(data[i][j] < 10){//右对齐 
110.                     System.out.print(' '); 
111.                 } 
112.                 System.out.print(data[i][j]); 
113.                 System.out.print(' '); 
114.             } 
115.            System.out.println(); 
116.         }