Go语言视频零基础入门到精通

javalearner

所谓的螺旋矩阵，指如下形式的H列*L行的矩阵：
     如何编程产生呢，ChinaJavaWorld技术论坛上曾经有不少爱好者给出过自己的解答，这里选两个易理解算法的程序学习。 一、方法一 沿如图方向，沿各个矩形边框依次给矩阵的每一个元素赋值，在计算机内存中构造一个完整的螺旋矩阵，然后输出。   代码：

1. public class Test {
   
2. public static int[][] makeMatrix(int w, int h) {
   
3.    int[][] mtr = new int[w][h];
   
4.    int d = 1, x = 0, y = 0;
   
5.    while(true) {
   
6.      mtr[x][y] = d++;
   
7.      //各方向可否前进
   
8.      boolean right = x< w-1&&mtr[x+1][y]==0;
   
9.      boolean down = y< h-1&&mtr[x][y+1]==0;
   
10.      boolean left = x>0&&mtr[x-1][y]==0;
    
11.      boolean up = y>0&&mtr[x][y-1]==0;
    
12.      //判断前进方向
    
13.      if(right) if(up) y--; else x++;
    
14.      else if(down) if(right) x++; else y++;
    
15.      else if(left) if(down) y--; else x--;
    
16.      else if(up) if(left) x--; else y--;
    
17.      else break;
    
18.    }
    
19.    return mtr;
    
20. }
    
21.   
    
22. public static void printMatrix(int[][] mtr) { //输出
    
23.    int w = mtr.length;
    
24.    int h = mtr[0].length;
    
25.    for(int i=0; i< h; i++) {
    
26.      for(int j=0; j< w; j++) {
    
27.        System.out.print(mtr[j][i] + "        ");
    
28.      }
    
29.      System.out.println ();
    
30.    }
    
31. }
    
32.   
    
33. public static void main(String[] args) {
    
34.    int h = Integer.parseInt(args[0]);
    
35.    int w = Integer.parseInt(args[1]);
    
36.    printMatrix(makeMatrix(h,w));
    
37. }
    
38. }
    

复制代码

  
   
   

     
   

     
   
  
二、方法二     做出数学模型, 直接计算每一个坐标上的值, 这样就不用存放一个完整的矩阵在内存中， 要频繁引用的话，可以调用这个算法预先生成一个矩阵存起来。
代码：

1. /*
2. * 作者：yanjj98
3. * 基本思路：采用数学方法直接计算出矩阵元素P(x,y)的值.
4. * 将整个矩阵看成由一个一个的矩形圈组成,矩阵中某一矩形圈上任意一点P(x,y)的值=
5. * 位于外圈的所有点数+本圈处于点p(x,y)前面的所有点数+1
6. */
7. 
   
8. public class Martrix
   
9. {
   
10.    private int H;
    
11.    private int L;
    
12. 
    
13.    public static void main(String argv[])
    
14.    {
    
15.        int h = Integer.parseInt(argv[0]);
    
16.        int w = Integer.parseInt(argv[1]);
    
17.        Martrix m1=new Martrix(h,w);
    
18.        m1.print();
    
19.    }
    
20.    
    
21.    public Martrix()
    
22.    {
    
23.        this.H=3;
    
24.        this.L=3;
    
25.    }
    
26.    public Martrix(int x,int y)
    
27.    {
    
28.        this.H=x;
    
29.        this.L=y;
    
30.    }
    
31. 
    
32.    //计算点p(x,y)的值
    
33.    public int getDotCount(int x,int y)
    
34.    {
    
35.        return getDotCount1(H,L,x,y) + getDotCount2(H,L,x,y) + 1;
    
36.    }
    
37. 
    
38.    //计算点P(x,y)外围矩形圈数
    
39.    public static int getN(int H,int L,int x,int y)
    
40.    {
    
41.        return Math.min(Math.min(x,y),Math.min((H-x),(L-y)));
    
42.    }
    
43. 
    
44.    //计算点P(x,y)外围矩形圈上的点数 (等差数列，这个等差数列的公差为-8)
    
45.    public static int getDotCount1(int H,int L,int x,int y)
    
46.    {
    
47.        int N=getN(H,L,x,y);//等差数列的项数
    
48.        int S1=2*(H+L);     //等差数列的第一项，即最外围矩形上的点数
    
49.        int S2=2*(H+L)-8*N + 8;//等差数列的第N项，即最后一圈矩形上的点数
    
50.        return (S1+S2)/2 * N;  //返回等差数列的和
    
51.    }
    
52. 
    
53.    //计算与点P(x,y)处于同一个矩形圈上，且在点P前面的所有点数 (分段函数)
    
54.    public static int getDotCount2(int H,int L,int x,int y)
    
55.    {
    
56.        int N=getN(H,L,x,y);
    
57.        int x1=x-N;
    
58.        int y1=y-N;
    
59.        int H1=H-2*N;
    
60.        int L1=L-2*N;
    
61.        int count;
    
62. 
    
63. 
    
64.        if(L1==0) //特列：H >=L ,L为奇数,y=(L-1)/2 实例(H=6,L=5,x=3,y=3)
    
65.           return x1 ;
    
66. 
    
67.        if(H1==0) //特列: H < L ,H为奇数,x=(H-1)/2 实例(H=5,L=6,x=3,y=3)
    
68.           return y1;
    
69.       
    
70.        if(y1==0) //一般情况:
    
71.        {
    
72.            count=x1;
    
73.        }
    
74.        else if(x1==H1) //一般情况:
    
75.        {
    
76.            count=H1 + y1;
    
77.        }
    
78.        else if(y1==L1) //一般情况:
    
79.        {
    
80.            count=H1 + L1 + (H1 - x1);
    
81.        }
    
82.        else if(x1==0) //一般情况:
    
83.        {
    
84.            count=H1 + L1 + (H1 - x1) + (L1 - y1);
    
85.        }
    
86.        else  //出错情况:
    
87.        {
    
88.            count= -1;
    
89.        }
    
90. 
    
91.        return count;
    
92.    }
    
93. 
    
94.    //计算并输出螺旋矩阵
    
95.    public void print()
    
96.    {
    
97.         System.out.println("H = " + H +" , " + "L = " + L);
    
98.         System.out.println("******************************************");
    
99.         for(int j=0;j<=L;j++)
    
100.         {
     
101.             for(int i=0;i<=H;i++)
     
102.             {
     
103.                 System.out.print(getDotCount(i,j)+"        ");
     
104.             }
     
105.             System.out.println();
     
106.         }
     
107.         System.out.println("************************************");
     
108.    }
     
109. }
     
110. 一次运行图：
     
111. D:java>java   Martrix 8 9
112. H = 8 , L = 9
113. ******************************************
114. 1       2       3       4       5       6       7       8       9
115. 34      35      36      37      38      39      40      41      10
116. 33      60      61      62      63      64      65      42      11
117. 32      59      78      79      80      81      66      43      12
118. 31      58      77      88      89      82      67      44      13
119. 30      57      76      87      90      83      68      45      14
120. 29      56      75      86      85      84      69      46      15
121. 28      55      74      73      72      71      70      47      16
122. 27      54      53      52      51      50      49      48      17
123. 26      25      24      23      22      21      20      19      18
124. ************************************

复制代码

  
  
   
   

     
   

     
   
  



源码下载：http://file.javaxxz.com/2014/11/7/000348093.zip