输入一个数，然后显示这样规律的图怎样做
1 2
4 3


7 8 9
6 1 2
5 4 3




7  8  9  10
6  1  2  11
5  4  3  12
16 15 14 13

这是一个数字按照逆时针填充的的图像。
一个数字包含三个信息，它的值、x坐标和y坐标
令数字1的坐标为（0，0）.
那么他的下一个数2，填充到其右边的位置，坐标为（1，0）
这时就要检查2的逆时针位置（1，-1）是否有数字存在，
如果有，则3应填充在2的右边（2，0），如果没有，则3填充在2的下边（1，-1）。
以此类推，检查当前数字的逆时针位置，
如果已经有数字存在，则按照当前数字的填充方向，继续填充
如果没有数字存在，则填充到逆时针位置
将所有数字的值和坐标信息保存在列表中
输出时，先输出最上面的一列（y坐标最大），从x坐标最小的数开始输出
换行后，输出y坐标减1的那一列，也是从x坐标最小的数开始输出
直到输出全部的数字
就可以达到楼主的效果

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. 
   
6. namespace ConsoleApplication2
   
7. {
   
8.     class Program
   
9.     {
   
10.         static void Main(string[] args)
    
11.         {
    
12.             
    
13.             //坐标极限值
    
14.             int xMin = 0;
    
15.             int xMax = 0;
    
16.             int yMin = 0;
    
17.             int yMax = 0;
    
18.             //表，用于保存数字坐标
    
19.             List<NumInfo> numList =new List<NumInfo>();
    
20.             //当前数字
    
21.             NumInfo currentNum=new NumInfo();
    
22.             //当前数字逆时针位置的数字
    
23.             NumInfo nextNum = new NumInfo();
    
24.             //数字的填充方向
    
25.             MoveTo move = MoveTo.Right;
    
26.             
    
27.             Console.WriteLine("请输入一个数字");
    
28.             //获取输入的数字
    
29.             int numGet = 0;
    
30.             try
    
31.             {
    
32.                 numGet = int.Parse(Console.ReadLine());
    
33.             }
    
34.             catch(Exception e)
    
35.             {
    
36.                 Console.WriteLine(e.Message);
    
37.             }
    
38.             //给每个数字添加坐标
    
39.             for (int i = 1; i <= numGet; i++)
    
40.             {
    
41.                 if (i == 1)
    
42.                 {
    
43.                     currentNum.Num = i;
    
44.                     currentNum.x = 0;
    
45.                     currentNum.y = 0;
    
46.                     numList.Add(currentNum);
    
47.                     //指定下一次数字出现的方向
    
48.                     move = MoveTo.Right;
    
49.                 }
    
50.                 else
    
51.                 {
    
52.                     currentNum.Num = i;
    
53.                     nextNum = currentNum;
    
54.                     switch (move)
    
55.                     {
    
56.                         case MoveTo.Right:
    
57.                             currentNum.x++;//向右填充，x增加
    
58.                             if (xMax < currentNum.x)
    
59.                             {
    
60.                                 xMax = currentNum.x;//保存x的最大值
    
61.                             }
    
62.                             nextNum.x=currentNum.x;//因为当前向右填充，所以检查下方位置，x不变
    
63.                             nextNum.y--;//因为当前向右填充，所以检查下方位置，y减1
    
64.                             break;
    
65.                         case MoveTo.Down:
    
66.                             currentNum.y--;
    
67.                             if (yMin > currentNum.y)
    
68.                             {
    
69.                                 yMin = currentNum.y;
    
70.                             }
    
71.                             nextNum.y = currentNum.y;
    
72.                             nextNum.x--;
    
73.                             break;
    
74.                         case MoveTo.Left:
    
75.                             currentNum.x--;
    
76.                             if (xMin > currentNum.x)
    
77.                             {
    
78.                                 xMin = currentNum.x;
    
79.                             }
    
80.                             nextNum.x = currentNum.x;
    
81.                             nextNum.y++;
    
82.                             break;
    
83.                         case MoveTo.Up:
    
84.                             currentNum.y++;
    
85.                             if (yMax < currentNum.y)
    
86.                             {
    
87.                                 yMax = currentNum.y;
    
88.                             }
    
89.                             nextNum.y = currentNum.y;
    
90.                             nextNum.x++;
    
91.                             break;
    
92.                     }
    
93.                     //将当前数字的信息添加到列表中
    
94.                     numList.Add(currentNum);
    
95. 
    
96.                     //检查逆时针方向的下一个点有无点,若无，则变化填充方向。
    
97.                     for (int j = 0; j < numList.Count; j++)
    
98.                     {
    
99.                         //有一个点在逆时针方向的下一个点的位置
    
100.                         if ((nextNum.x == numList[j].x) && (nextNum.y == numList[j].y))
     
101.                         {
     
102.                             break;
     
103.                         }
     
104.                             //不存在这样的点，改变填充方向
     
105.                         else if (j == numList.Count-1)
     
106.                         {
     
107.                             switch (move)
     
108.                             {
     
109.                                 case MoveTo.Right:
     
110.                                     move = MoveTo.Down;//右逆时针旋转后为向下
     
111.                                     break;
     
112.                                 case MoveTo.Down:
     
113.                                     move = MoveTo.Left;
     
114.                                     break;
     
115.                                 case MoveTo.Left:
     
116.                                     move = MoveTo.Up;
     
117.                                     break;
     
118.                                 case MoveTo.Up:
     
119.                                     move = MoveTo.Right;
     
120.                                     break;
     
121.                             }
     
122.                         }
     
123.                     }
     
124.                 }
     
125.             }
     
126.             //数字坐标生成完毕
     
127.             //输出数字
     
128.             for (int y = yMax; y >= yMin; y--)
     
129.             {
     
130.                 for (int x = xMin; x <= xMax; x++)
     
131.                 {
     
132.                     //查找坐标为（x，y）的数字并输出，若无，则用空格填充
     
133.                     string tempNum=null;
     
134. 
     
135.                     for (int n = 0; n < numList.Count; n++)
     
136.                     {
     
137.                         if (numList[n].x == x && numList[n].y == y)
     
138.                         {
     
139.                             tempNum = numList[n].Num.ToString();
     
140.                             numList.RemoveAt(n);
     
141.                             break;
     
142.                         }
     
143.                         else if (numList.Count - 1 == n)
     
144.                         {
     
145.                             tempNum = " ";
     
146.                         }
     
147.                     }
     
148.                     Console.Write(tempNum);
     
149.                     if (x < xMax)
     
150.                     {
     
151.                         Console.Write("\t");
     
152.                     }
     
153.                 }
     
154.                 Console.WriteLine();
     
155.             }
     
156.             Console.ReadLine();
     
157.         }
     
158.     }
     
159.     //定义一个结构体用于记录数字的信息
     
160.     struct NumInfo
     
161.     {
     
162.         public int Num;
     
163.         public int x;
     
164.         public int y;
     
165.     }
     
166.     enum MoveTo { Right, Down, Left, Up }
     
167. }
     
168. //这是参考代码

复制代码

楼上的你

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. 
   
6. namespace 螺旋矩阵
   
7. {
   
8.     class Program
   
9.     {
   
10.         static void Main(string[] args)
    
11.         {
    
12.             /*
    
13.              思路：
    
14.              从样例给中的矩阵也就是n=7的时候，我们可以发现以下规律：
    
15.              * //第一圈
    
16.              * 1向右走1步就可以达到2
    
17.              * 然后2向下走1步可以达到3
    
18.              * 然后3向左走2步可以到5
    
19.              * 然后5向上走2步可以达到7
    
20.              //第二圈
    
21.               * 7向右走3步就可以达到10
    
22.              * 然后10向下走3步可以达到13
    
23.              * 然后13向左走4步可以到17
    
24.              * 然后17向上走4步可以达到21
    
25.              ==============================
    
26.               得出
    
27.               向右走的步数为1,3,5,7 ...2*n+1;
    
28.               向下走的步数为1,3,5,7 ...2*n+1;
    
29.               向左走的步数为2,4,6,8 ...2*n;
    
30.               向上走的步数为2,4,6,8 ...2*n;
    
31.               然后就是根据此规律得出一个螺旋矩阵
    
32.             
    
33.              *
    
34.              */
    
35. 
    
36. 
    
37.             Console.WriteLine("请输入n的值");
    
38.             string str = Console.ReadLine();
    
39.             int n, i, j;
    
40.             //定义一个二维数组a
    
41.             int [,]a=new int[100,100];
    
42.             //定义一个string数组s
    
43.             string[,] s = new string[100, 100];
    
44.             bool flag=int.TryParse(str, out n);
    
45.             if (flag)
    
46.             {
    
47.                 //数组初始化
    
48.                 for ( i = 1; i <=n; i++)
    
49.                 {
    
50.                     for (j = 1; j <=n; j++)
    
51.                     {
    
52.                         a[i, j] = 0;                    
    
53.                     }
    
54.                 }
    
55.                 //posI,posJ表示1的初始位置
    
56.                 int posI = (n + 1) / 2;
    
57.                 int posJ = (n + 1) / 2;
    
58.                 a[posI, posJ] = 1;
    
59.                 int k = 1,f=0;//k表示从1开始到n*n,f计数
    
60.                 while (k<=n*n)
    
61.                 {
    
62.                     //向右1 3  5  7
    
63.                     for (i = 1; i <= 2 * f + 1; i++)
    
64.                         a[posI, ++posJ] = ++k;                             
    
65.                     //向下1 3  5  7
    
66.                     for (i = 1; i <= 2 * f + 1; i++)
    
67.                         a[++posI, posJ] = ++k;
    
68. 
    
69.                     //向左2 4  6  8
    
70.                     for (i = 1; i <= 2 *(f+1) ; i++)
    
71.                         a[posI, --posJ] = ++k;
    
72. 
    
73.                     //向上2 4  6  8
    
74.                     for (i = 1; i <= 2 *(f + 1); i++)
    
75.                         a[--posI, posJ] = ++k;
    
76.                     f++;
    
77. 
    
78.                 }            
    
79.                 Console.WriteLine("得到的图形为:");
    
80.                 for (i = 0; i <n + 2; i++)
    
81.                     s[0, i] = "*";        
    
82.                 for (i = 1; i <= n; i++)
    
83.                 {
    
84.                     s[i, 0] = "*";
    
85.                     for (j = 1; j <= n; j++)
    
86.                     {
    
87.                         
    
88.                         s[i, j] = a[i, j].ToString();                        
    
89.                     }
    
90.                     s[i , n+1] = "*";            
    
91.                 }
    
92.                 for (i = 0; i < n + 2; i++)
    
93.                     s[n+1, i] = "*";
    
94.                 for (i = 0; i < n + 2; i++)
    
95.                 {
    
96.                     for (j = 0; j <n + 2; j++)
    
97.                     {
    
98.                         Console.Write("{0,-8}",s[i,j]);              
    
99.                     }
    
100.                     Console.WriteLine();
     
101.                 }
     
102.             }
     
103.            
     
104.         }
     
105.     }
     
106. }
     

复制代码

好难的说，完全不懂，