看到别人用Java写，我就用JS做了个：http://bbs.itheima.com/thread-224667-1-1.html
我自己研究算法的时候喜欢用JS- -
原因是语法简单，不像Java需要那么多东西- -
以及不需要开IDE，浏览器即可调试OK上代码：

1. !function() {
   
2.     /**
   
3.      * 输出螺旋数列
   
4.      * @param size 要输出的矩阵的长与宽
   
5.      * @param startNum 从哪个数字开始输出
   
6.      * @param directions 方向列表，应该为正好包含4个整数的数组，1上2下3左4右
   
7.      * @param startX 开始X坐标
   
8.      * @param startY 开始Y坐标
   
9.      */
   
10.     function xxx(size, startNum, directions, startX, startY, numStep) {
    
11.         // 初始化存储区域
    
12.         var array = [];
    
13.         for (var i = 0; i < size; i++) {
    
14.             array[i] = [];
    
15.         }
    
16. 
    
17.         // 生成数字
    
18.         var s = size;         // 当前的输出大小
    
19.         var n = 1;            // 还有几次循环要减少输出大小
    
20.         var directionID = 0;  // 当前输出方向
    
21.         var x = startX;       // 当前的x坐标
    
22.         var y = startY;       // 当前的y坐标
    
23.         var num = startNum;   // 当前的数字
    
24.         //首先对开始坐标进行修正
    
25.         var firstDirection = directions[directionID];
    
26.         if (firstDirection == 1) {
    
27.             x++;
    
28.         } else if (firstDirection == 2) {
    
29.             x--;
    
30.         } else if (firstDirection == 3) {
    
31.             y++;
    
32.         } else {
    
33.             y--;
    
34.         }
    
35.         //主要输出循环
    
36.         while (s > 0) {
    
37.             // 生成一行或者一列数字
    
38.             var direction = directions[directionID]; //本次输出的方向
    
39.             for (var i = 0; i < s; i++) {
    
40.                 // 首先根据方向计算出输出的目标坐标
    
41.                 if (direction == 1) {
    
42.                     x--;
    
43.                 } else if (direction == 2) {
    
44.                     x++;
    
45.                 } else if (direction == 3) {
    
46.                     y--;
    
47.                 } else {
    
48.                     y++;
    
49.                 }
    
50. 
    
51.                 // 然后将目标数字输出到指定坐标
    
52.                 array[x][y] = num;
    
53.                 num += numStep;
    
54.             }
    
55. 
    
56.             // 控制输出大小的缩小
    
57.             n--;
    
58.             if (!n) {
    
59.                 n = 2;
    
60.                 s--;
    
61.             }
    
62.             // 控制方向的更变
    
63.             directionID++;
    
64.             if (directionID == 4) {
    
65.                 directionID = 0;
    
66.             }
    
67.         }
    
68.         
    
69.         // 准备结果
    
70.         var result = "";
    
71.         for (var i = 0; i < size; i++) {
    
72.             for(var j = 0; j < size; j++) {
    
73.                 result += array[i][j] + "\t";
    
74.             }
    
75.             result += "\n";
    
76.         }
    
77. 
    
78.         //返回结果
    
79.         return result;
    
80.     }
    
81. 
    
82.     //演示: 顺时针输出
    
83.     var str = xxx(10, 1, [4, 2, 3, 1], 0, 0, 1);
    
84.     console.log(str);
    
85.     //演示: 逆时针输出
    
86.     var str = xxx(9, 1, [2, 4, 1, 3], 0, 0, 1);
    
87.     console.log(str);
    
88.     //演示: 从右下角开始的逆时针输出
    
89.     var str = xxx(9, 1, [1, 3, 2, 4], 8, 8, 1);
    
90.     console.log(str);
    
91.     //演示: 从右上角开始的顺时针输出 从200开始每次减2
    
92.     var str = xxx(9, 200, [2, 3, 1, 4], 0, 8, -2);
    
93.     console.log(str);
    
94. }();
    

复制代码

输出：

1. 1         2         3         4         5         6         7         8         9         10        
   
2. 36        37        38        39        40        41        42        43        44        11        
   
3. 35        64        65        66        67        68        69        70        45        12        
   
4. 34        63        84        85        86        87        88        71        46        13        
   
5. 33        62        83        96        97        98        89        72        47        14        
   
6. 32        61        82        95        100       99        90        73        48        15        
   
7. 31        60        81        94        93        92        91        74        49        16        
   
8. 30        59        80        79        78        77        76        75        50        17        
   
9. 29        58        57        56        55        54        53        52        51        18        
   
10. 28        27        26        25        24        23        22        21        20        19        
    
11. 
    
12. 1        32        31        30        29        28        27        26        25        
    
13. 2        33        56        55        54        53        52        51        24        
    
14. 3        34        57        72        71        70        69        50        23        
    
15. 4        35        58        73        80        79        68        49        22        
    
16. 5        36        59        74        81        78        67        48        21        
    
17. 6        37        60        75        76        77        66        47        20        
    
18. 7        38        61        62        63        64        65        46        19        
    
19. 8        39        40        41        42        43        44        45        18        
    
20. 9        10        11        12        13        14        15        16        17        
    
21. 
    
22. 17        16        15        14        13        12        11        10        9        
    
23. 18        45        44        43        42        41        40        39        8        
    
24. 19        46        65        64        63        62        61        38        7        
    
25. 20        47        66        77        76        75        60        37        6        
    
26. 21        48        67        78        81        74        59        36        5        
    
27. 22        49        68        79        80        73        58        35        4        
    
28. 23        50        69        70        71        72        57        34        3        
    
29. 24        51        52        53        54        55        56        33        2        
    
30. 25        26        27        28        29        30        31        32        1        
    
31. 
    
32. 152        150        148        146        144        142        140        138        200        
    
33. 154        100        98         96         94         92         90         136        198        
    
34. 156        102        64         62         60         58         88         134        196        
    
35. 158        104        66         44         42         56         86         132        194        
    
36. 160        106        68         46         40         54         84         130        192        
    
37. 162        108        70         48         50         52         82         128        190        
    
38. 164        110        72         74         76         78         80         126        188        
    
39. 166        112        114        116        118        120        122        124        186        
    
40. 168        170        172        174        176        178        180        182        184

复制代码

赞一个，不错不错