要求从键盘上输入一个数字，比如3输出成这个样子
11111
12221
12321
12221
11111

1. /*
   
2.   * tmp:要生成的螺旋数字的最大值
   
3.   */
   
4. public static void foo(int tmp) {
   
5.   int n = tmp * 2 - 1;
   
6.   int[][] arr = new int[n][n];
   
7.   // 矩阵下三角的上半部，即：
   
8.   /*
   
9.    * 1
   
10.    * 1  2
    
11.    * 1  2  3
    
12.    */
    
13.   for (int i = 0; i <= n / 2; i++) {
    
14.    for (int j = 0; j <= i; j++) {
    
15.     arr[i][j] = j + 1;
    
16.    }
    
17.   }
    
18.   //以1  2  3为对称线，生成下半部，即：
    
19.   /*
    
20.    * 1  2
    
21.    * 1
    
22.    */
    
23.   for (int i = n - 1; i > n / 2; i--) {
    
24.    for (int j = 0; j <= n - i - 1; j++) {
    
25.     arr[i][j] = arr[n - i - 1][j];
    
26.    }
    
27.   }
    
28.   //以斜对角线的一半为对称线，生成下三角的剩余部分，即：
    
29.   /*
    
30.    *    2  
    
31.    * 1  1  1  
    
32.    */
    
33.   for (int i = n - 1; i > n / 2; i--) {
    
34.    for (int j = n - i - 1; j < n; j++) {
    
35.     arr[i][j] = arr[n - 1 - j][n - 1 - i];
    
36.    }
    
37.   }
    
38.   //以主对角线为对称线，生成上三角
    
39.   for (int i = 0; i < n - 1; i++) {
    
40.    for (int j = i + 1; j < n; j++) {
    
41.     arr[i][j] = arr[j][i];
    
42.    }
    
43.   }
    
44.   //打印整个矩阵
    
45.   for (int i = 0; i < n; i++) {
    
46.    for (int j = 0; j < n; j++) {
    
47.     System.out.print(arr[i][j]);
    
48.    }
    
49.    System.out.println();
    
50.   }
    
51. }
    

复制代码

1. /*
   
2. 要求：要求从键盘上输入一个数字，比如3输出成这个样子
   
3. 11111
   
4. 12221
   
5. 12321
   
6. 12221
   
7. 11111
   
8. 
   
9. 分析:
   
10. 1.根据一个数字从大到小，然后再从小到达，类似一个拱桥。
    
11. 2.每次循环次数等于这个数乘2减1
    
12. 3.第一行循环时，数值最大值等于1，第二行时最大值等于二。依次类推
    
13. 
    
14. 思路：
    
15. 1.使用循环语句嵌套实现
    
16. 2.最外部的循环控制总行数循环
    
17. */
    
18. class  LuoXuan
    
19. {
    
20.         public static void main(String[] args)
    
21.         {       
    
22.                 int x,y,sum;
    
23.                 x = y = 1;
    
24.                 sum = 3 ;
    
25.                 while (x < sum*2-1)
    
26.                 {
    
27.                
    
28.                         if (x >sum)
    
29.                         {
    
30.                                         System.out.println(x);
    
31.                         }
    
32.                         x++;
    
33.                 }
    
34. 
    
35.         }
    
36. }
    

复制代码

/*
思路：这个回文横竖从中间分成四部分，分别考虑四个象限的规律打印。

*/
public class Test
{
       
        public static void main(String[] args)
        {
                Test t=new Test();
                t.huiwen(3);
        }

        public void huiwen(int m)
        {
           int x=0;
           for(int i=1;i<=2*m-1;i++)
             {
               
                for(int j=1;j<=2*m-1;j++)
                 {
                        if(i<=m&j<=m)
                                {
                                        if(j<=i)
                                                x=j;
                                        else
                                                x=i;
                                }
                        if(i<=m&j>m)
                                {
                                        if(2*m-j<=i)
                                                x=2*m-j;
                                        else
                                                x=i;
                                }
                        if(i>m&j<m)
                                {
                                        if(2*m-i>=j)
                                                x=j;
                                        else
                                                x=2*m-i;
                                }
                        if(i>m&j>m)
                                {
                                        if(2*m-i<=2*m-j)
                                                x=2*m-i;
                                        else
                                                x=2*m-j;
                                }
                                System.out.print(x);
                        }
                        System.out.println();
           }               
  }

}

求技术分……

大于等于10的时候，螺旋就不对称了。如图：

郭孟涛 发表于 2013-1-25 03:27
大于等于10的时候，螺旋就不对称了。如图：

算法没错，只是输出的时候忘记考虑单位数和多位数的占位宽度问题，可以在输出X的语句加判断x所占宽度，小鱼刺宽度的输出补上相应的空格即可