java实现蛇形算法

package aglo;

public class test {

	/**
	 * 描述一:
	 * 5行5列蛇形算法
	 * (0,0)(4,4)-第1行和倒数1行相差4
	 * (1,0)(4,3)(0,1)(3,4)-第2行和倒数2行相差3
	 * (0,2)(2,4)(1,1)(3,3)(2,0)(4,2)-第3行和倒数3行相差2
	 * (3,0)(4,1)(2,1)(3,2)(1,2)(2,3)(0,3)(1,4)-第4行和倒数4行相差1
	 * 第5行为分割行
	 * 根据上面的描述,得到下面的算法
	 */
	/**
	 * 描述二:
	 * dao变量作用:
	 * 主要计算下对角线的坐标值。
	 * 例如:5行5列 
	 * {
		   (0,0)                  --称为行0
　　		   (1,0)(0,1)             --称为行1
　　         (0,2)(1,1)(2,0)        --称为行2
　　         (3,0)(2,1)(1,2)(0,3)   --称为行3
	   }---上对角线所有坐标
       (0,4)(1,3)(2,2)(3,1)(4,0)---此处称为对角线4
	   {
		　　(4,1)(3,2)(2,3)(1,4)  --称为行5
		　　(2,4)(3,3)(4,2)       --称为行6
		　　(4,3)(3,4)            --称为行7
		　　(4,4)                 --称为行8
	   }---下对角线所有坐标
	   dao变量最大值是行*列
	   得到下对角线所有坐标的值主要是靠dao变量和temp变量发挥作用
	 */
	/**
	 * @param irow 行
	 * @param icol 列
	 * @param sheLength 几节蛇段,也就是行加对角线
	 */
	public void sheAglo(int irow,int icol,int sheLength){
		int row = 0,col = 0;
		int ban = (sheLength-1)/2+1;
		int array[][] = new int[irow][icol];
		int m = 1,num = ban - 1;
		int dao = irow*icol;
		for(int i=0;i<ban;i++){
			row = col = i;
			int  temp = dao-i;//第n行下对角线值从dao-i开始
			if(i%2==0){		//处理双行	
				/**
				 * (0,0)
				 * (0,2)(1,1)(2,0)
				 * 特点是行递增,列递减
				 */
				while(col>=0){
					System.out.print("["+(i-col)+"]["+(col)+"]("+m+"),");
					if(i!=ban-1){//该此是对角线
						System.out.print("["+(i-col+num)+"]["+(col+num)+"]("+(temp++)+"),");
					}
					array[i-col][col] = m;
					dao--;
					col--;
					m++;
				}
			}else if(i%2!=0){//处理单行
				/**
				 * (1,0)(0,1)
				 * (3,0)(2,1)(1,2)(0,3)
				 * 特点是行递减,列递增
				 */
				while(row>=0){
					System.out.print("["+(row)+"]["+(i-row)+"]("+m+"),");
					if(i!=ban-1){
						System.out.print("["+(row+num)+"]["+(i-row+num)+"]("+(temp++)+"),");
					}
					array[row][i-row] = m;
					dao--;
					row--;
					m++;
				}
			}
			num--;
			System.out.println();
		}
	}
	
	public static void main(String args[]){
		test test = new test();
		test.sheAglo(6,6,11);
	}
	
}

 该算法只能支持行、列相同的矩阵。

参考资源一:

 

在描述算法之前，先看看下面的5*5的表格：

1	3	4	10	11
2	5	9	12	19
6	8	13	18	20
7	14	17	21	24
15	16	22	23	25

　　上面的表格很容易看出规律。就是从左上角第一个格开始（起始为1），然后延右上角到左下角的斜线。先从下到上，再从上到下。开始按数字递增排列。也就是说每一个斜线上分别有如下几组数字：

　　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

　　由于是先从上到下（1可以看做是从上到下），再从下到上，很象一条蛇，因此，该数字表格也可称为蛇形矩阵。现在要与一个方法（或函数），方法的参数是一个int类型，表示n，方法返回一个二维数组，表示要获得的往返接力数字表格。

　　实际上，这个算法并不复杂，只需要从分别获得1至n^2中每个数字对应的二维数组的坐标就可以了。先拿这个5行5列的表格来说，求出上面每组数组对应的坐标（起始位置为0）。

第0组 　　第1组 　　第2组 　　第3组 　　第4组 　　第5组 　　第6组 　　第7组 　　第8组

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

(0,0) 　　(1,0)　　 (0,1) 　　(0,2) 　 (1,1)　　 (2,0) 　　(3,0)　　 (2,1)　　 (1,2)　　 (0,3) 　　(0,4)　　 (1,3)　　 (2,2)　　 (3,1)　　 (4,0) 　　(4,1)　　 (3,2)　　 (2,3)　　 (1,4) 　　(2,4)　　 (3,3) 　 (4,2) 　　(4,3)　　 (3,4) 　　(4,4)

　　从上面的从标可以看出一个规律。　 左上角的半个表格（以对角线分界）的横坐标和纵坐标从0开始，每一组增1，直到增至表格的边界（n - 1），而且是交替的，也就是说，偶数行是列增，行减小，行+列=组的索引。而右下角的4组数字虽然行、列也是交替增长的，但递减的行或列总是从(n - 1)开始（对于本例，是从4开始），而递增的行或列总是从index - n + 1开始，其中index表示组的索引。这就可以得出一个算法。实现代码如下：

public　static　int[][]　getGrid(int　n)
{
　　　　int[][]　array　=　new　int[n][n];
　　　　int　row　=　0,　col　=　0,　m　=　1;
　　　　//　　用于控制奇偶组，false表示偶组，true表示奇组
　　　　boolean　isRow　=　false;
　　　　//　　i表示当前组的索引，从0开始
　　　　for　(int　i　=　0;　i　<　(2　*　n　-　1);　i++)
　　　　{
　　　　　　　　row　=　i;
　　　　　　　　while　(row　>=　((i　<　n)　?　0　:　i　-　n　+　1))
　　　　　　　　{
　　　　　　　　　　　　//　　如果处理的是右下角表格中的数字，行或列最大不能超过n-1
　　　　　　　　　　　　if　(row　>　(n　-　1))
　　　　　　　　　　　　　　　　row　=　n　-　1;
　　　　　　　　　　　　col　=　i　-　row;
　　　　　　　　　　　　if　(isRow)
　　　　　　　　　　　　　　　　array[row][col]　=　m;
　　　　　　　　　　　　else　　//　　将row变成列，将col变成行
　　　　　　　　　　　　　　　　array[col][row]　=　m;
　　　　　　　　　　　　m++;
　　　　　　　　　　　　row--;
　　　　　　　　}
　　　　　　　　//　　切换奇偶组
　　　　　　　　isRow　=　!isRow;
　　　　}
　　　　return　array;
}

　　另一种算法

　　上面实现的算法需要循环N*N次才可以生成蛇形矩阵。但仔细分析一下，还可以稍微变换一下这个算法，使循环次数减小至N*N/2。我们上学时曾学过用高斯的方法计算1+2+3+...+100， 　 1 + 100 = 101，2 + 99 = 101，...，50+51 = 101，因此，结果是101 * 50 = 5050。很方便。我们这个算法也可采用类似的方法。仔细观察上面5*5的数字表格发现，算出左上角的矩阵中每一个数字后，都可以直接获得右下角度某个位置的数字。例如在(0,0)位置的1，可以向到(4,4)位置的25，(1,2)位置的9可以得到(3,2)位置的17。我们发现，每一对数之和都为 26。而且它们坐标的关系是(row,col)，(n - row - 1, n - col - 1)。因此，只要得到左上角的半个矩阵，就可以得出右下角的另外半个矩阵。如果n为奇数，对角线中间的一个数（在5*5的矩阵中是13）与之对应的数是其自身。好，我们看看改进的算法的实现：

public　static　int[][]　getGrid1(int　n)
{
　　　　int[][]　array　=　new　int[n][n];
　　　　int　row　=　0,　col　=　0,　m　=　1;
　　　　int　number1　=　　(n　*　n　/　2　+　n　*　n　%　2);
　　　　int　number2　=　n　*　n　+　1;　　　　　　　　
　　　　boolean　isRow　=　false;
　　　　//　　number1表示要计算的蛇形矩阵中最大的数字，对于5*5矩阵来说该数是13
　　　　for　(int　i　=　0;　m　<　number1;　i++)
　　　　{
　　　　　　　　row　=　i;
　　　　　　　　while　(row　>=　0)
　　　　　　　　{
　　　　　　　　　　　　col　=　i　-　row;
　　　　　　　　　　　　if　(isRow)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　array[row][col]　=　m;
　　　　　　　　　　　　　　　　//　　填充与m对应的另外一个数
　　　　　　　　　　　　　　　　array[n　-　row　-　1][n　-　col　-　1]　=　number2　-　m;
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　array[col][row]　=　m;
　　　　　　　　　　　　　　　　//　　填充与m对应的另外一个数
　　　　　　　　　　　　　　　　array[n　-　col　-　1][n　-　row　-　1]　=　number2　-　m;
　　　　　　　　　　　　}
　　　　　　　　　　　　m++;
　　　　　　　　　　　　if(m　>=　number1)　break;
　　　　　　　　　　　　row--;
　　　　　　　　}
　　　　　　　　isRow　=　!isRow;
　　　　}
　　　　return　array;
}

　　上面的算法虽然将循环次数减少了一半，但每次循环的计算量增加了，因此，算法总体效率并没有提高。至于使用哪个算法，可根据实际情况决定。

　　如果想输出n=10的数字表格，可以使用int[][] grid = getGrid(10)或int[][] grid1 = getGrid1(10)，会得到同样的结果。输出grid和grid1，看看是不是下面的结果：

1	3	4	10	11	21	22	36	37	55
2	5	9	12	20	23	35	38	54	56
6	8	13	19	24	34	39	53	57	72
7	14	18	25	33	40	52	58	71	73
15	17	26	32	41	51	59	70	74	85
16	27	31	42	50	60	69	75	84	86
28	30	43	49	61	68	76	83	87	94
29	44	48	62	67	77	82	88	93	95
45	47	63	66	78	81	89	92	96	99
46	64	65	79	80	90	91	97	98	100

来源:http://tech.ddvip.com/2009-09/1253593588133921.html

参考资源二:

也说一下蛇形矩阵吧，蛇形矩阵有好几类，下面这个是其中之一：
                                      1    2     6     7
                                      3    5     8    13
                                      4    9    12   14
                                      10  11  15  16
这几天被这种矩阵吸引了，当然我觉得这是最不像“蛇形”的蛇形矩阵了哈。
然后呢，自己动手写了一段代码，也算实现了这种效果，可是算法上面太复杂了

for循环套着for循环，自己看着都晕，然后上网找了几条高手写的，终于发现了下面
这条很简洁的，可惜不知道这位大牛是谁啊。。
具体实现很简洁明了，我想说的是，这种不单能实现N*N的方阵，稍微变换下还能实现N*M的矩阵，

这种不规则的蛇形也很好玩的哈~
下面三图分别是4*4方阵，5*3矩阵和3*5矩阵，后面两个很好看嘛\(^o^)/~

下面附上代码，当然我写的就不拿来了，，，不丢人了。。。。。

C++语言 : snake

01 #include <iostream>
02 using namespace std ;
03 const int MAX = 20 ;
04
05 int main ()
06 {
07     int m , n;
08     int a [ MAX ][ MAX ];
09     cout << “输入矩阵行数和列数：” << endl ;
10     cin >> m >> n;
11
12     int i , j , s;
13     i = j = 0 ;
14     s = 1 ;
15     a [ i ][ j ] = s++ ;
16     while (s <= m * n)
17     {
18         //右移
19         if (j < n - 1 )
20             j ++ ;
21         else
22             i ++ ;
23         a [ i ][ j ] = s++ ;
24         //左下
25         while (i < m - 1 && j > 0 )
26             a [ ++ i ][ -- j ] = s++ ;
27         //下移
28         if (i < m - 1 )
29             i ++ ;
30         else
31             j ++ ;
32         a [ i ][ j ] = s++ ;
33         //右上
34         while (j < n - 1 && i > 0 )
35             a [ -- i ][ ++ j ] = s++ ;               
36     }    
37     for (int i = 0 ; i != m ; ++ i )
38     {
39         for (int j = 0 ; j != n; ++ j )
40             printf (“%3.0d” , a [ i ][ j ]);
41         cout << endl ;
42     }
43     return 0 ;
44 }

来源:http://www.ihonk.cn/blog/2009/06/14/129#more-129

<!-- 分页 --><!-- 分页end -->