魔方阵原理及十种解法（C语言）

最新推荐文章于 2023-07-07 14:05:27 发布

macans

最新推荐文章于 2023-07-07 14:05:27 发布

阅读量5.2w

点赞数 102

分类专栏： C/C++ 文章标签： C语言魔方阵幻方

C/C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

魔方阵，古代又称“纵横图”，是指组成元素为自然数1、2…n的平方的n×n的方阵，其中每个元素值都不相等，且每行、每列以及主、副对角线上各n个元素之和都相等。

如3×3的魔方阵：
    8   1   6
    3   5   7
    4   9   2
魔方阵的排列规律如下：
(1)将1放在第一行中间一列；
(2)从2开始直到n×n止各数依次按下列规则存放；每一个数存放的行比前一个数的行数减1，列数加1（例如上面的三阶魔方阵，5在4的上一行后一列）；
(3)如果上一个数的行数为1，则下一个数的行数为n(指最下一行);例如1在第一行，则2应放在最下一行，列数同样加1；
(4)当上一个数的列数为n时，下一个数的列数应为1，行数减去1。例如2在第3行最后一列，则3应放在第二行第一列；
(5)如果按上面规则确定的位置上已有数，或上一个数是第一行第n列时，则把下一个数放在上一个数的下面。例如按上面的规定，4应该放在第1行第2列，但该位置已经被占据，所以4就放在3的下面；

一、魔方阵的简介

1.何谓矩阵？矩阵就是由方程组的系数及常数所构成的方阵。把用在解线性方程组上既方便，又直观。

2.何谓n阶方阵？若一个矩阵是由n个横列与n个纵行所构成，共有个小方格，则称这个方阵是一个n阶方阵。

3.何谓魔方阵？ 4 9 2 3 5 7 8 1 6定义：由n*n个数字所组成的n阶方阵，具有各对角线，各横列与纵行的数字和都相等的性质，称为魔方阵。而这个相等的和称为魔术数字。若填入的数字是从1到n*n，称此种魔方阵为n阶正规魔方阵。

4.最早的魔方阵相传古时为了帮助治水专家大禹统治天下，由水中浮出两只庞大动物背上各负有一图，只有大禹才可指挥其中之由龙马负出的为河图，出自黄河；另一由理龟负出的洛书出自洛河。洛书

5.最早的四阶魔方阵最早的四阶方阵刻在印度一所庙宇石上，年代大约是十一世纪。古代印度人十分崇拜这种幻方，至今从古神殿的遗址，墓碑上常常还可以发现四阶幻方的遗迹。

6.欧洲最早的魔方阵欧洲最早的方阵是公元1514年德国画家Albrecht Dure在他著名的铜板画Melencolia上的4×4幻方，有趣的是，他连创造年代(1514)也镶在这个方阵中，而且上下左右，四个小方阵的和皆为34，是欧洲最古老的幻方。

二、魔方阵的变形

1.相异魔方阵对应方格所填的数字不相同的两个魔方阵，如下图
16 02 03 13 01 15 04 14 05 11 10 08 12 06 09 07 09 07 06 12 13 03 16 02 04 1415 01 08 10 05 11

2.相等魔方阵每一个对应方格所填的数字都相同的两个魔方阵，如下图4 9 2 4 9 2 3 5 7 3 5 7 8 1 6 8 1 6

3.全等魔方阵若一个魔方阵能够经过旋转或镜射的方式变成和另一个魔方阵相等，称这两个魔方阵全等。在计算魔方阵个数时，我们把全等的魔方阵视为同一种。 2 7 6 8 3 4 9 5 11 5 9 4 3 8 6 7 2

4,刚性变形法(1)顺时针方向旋转90 (2)顺时针方向旋转180 (3)顺时针方向旋转270 (4)左右翻转(绕铅直对称轴镜射) (5)上下翻转(绕水平对称轴镜射) (6)左上右下翻转(绕右上至左下对角线镜射) (7)右上左下翻转(绕左上至右下对角线镜射)

原始方阵旋转90。旋转180。旋转270。 01 03 16 14 12 08 13 01 07 05 10 12 14 04 09 07 13 15 02 04 10 06 15 0309 11 06 08 16 02 11 05 08 06 11 09 05 11 02 16 04 02 15 13 03 15 06 10 12 1005 07 07 09 04 14 14 16 03 01 01 13 08 12

左右翻转上下翻转左上右下翻转右上左下翻转14 16 03 01 12 10 05 07 07 09 04 14 01 13 0812 04 02 15 13 08 06 11 09 05 11 02 16 03 15 06 10 09 11 06 08 13 15 02 04 1006 15 03 16 02 11 05 07 05 10 12 01 03 16 14 12 08 13 01 14 04 09 07 5.加值变形法正规魔方阵：首项是1，公差是1加值变形后的魔方阵：首项是a，公差是r

原始魔方首项为5公差为1首项为5公差为2 14 16 03 01 18 20 07 05 31 35 09 05 04 02 15 13 08 06 19 17 11 07 33 2909 11 06 08 13 15 10 12 21 25 15 19 07 05 10 12 11 09 14 16 17 13 23 27

6.互补变形法就是将魔方阵中的每一个数字都替换成互补数的变形方式。在n阶魔方阵中，数字k的互补数=(1+n*n)–k

原始魔方阵互补变形魔方阵14 16 03 01 03 01 14 16 04 02 15 13 13 15 02 04 09 11 0608 08 06 11 09 07 05 10 12 10 12 07 05

7.田字变形法以中心点为准将魔方阵分成四个相等的小方阵。当n为奇数时，中央的行列要独立出来。

n是偶数时n是奇数时ABA A1 BDC? D1 E B1 D C1 C将魔方阵如下重组: CD ? C C1 D? BA B1E D1 B A1 A

可参考下面的范例:原始4阶魔方阵4阶田字变形魔方阵原始5阶魔方阵5阶田字变形魔方阵01 03 16 14 11 09 08 06 18 22 01 10 14 13 17 09 21 05 13 15 02 04 05 07 1210 04 08 12 16 25 24 03 20 07 11 08 06 11 09 16 14 01 03 15 19 23 02 06 02 0623 15 19 12 10 05 07 02 04 13 15 21 05 09 13 17 10 14 01 18 22 07 11 20 24 0316 25 12 04 08 8.井字对换变形法(1)任选一数k，1<=k<=n 。 (2)将方阵的第k行和其互补行(第n+1-k行)对换。 (3)将方阵的第k列和其互补列(第n+1-k列)对换。 (4)为方便称呼，此时姑且命名为k值井字对换变形。

原始魔方阵1值井字对换魔方阵2值井字对换魔方阵1,2值井字对换魔方阵01 03 16 14 07 10 05 12 01 16 03 14 07 05 10 12 13 15 02 04 04 15 02 13 0811 06 09 09 11 06 08 08 06 11 09 09 06 11 08 13 02 15 04 04 02 15 13 12 10 0507 14 03 16 01 12 05 10 07 14 16 03 01 9.拓朴变形法( 1)任选不相等的两数1<=k1,k2<=n，但当(n+1)/2为奇数时，k1及k2不能等于(n+1)/2。 (2)将座标含k1值的全改成k2。含k2值的全改成k1。含n+1-k1值的全改成n+1-k2。含n+1-k2值的全改成n+1-k1。 (3)为方便称呼，此时姑且命名为k1,k2拓朴变形。

可参考下面的3阶1，3拓朴变形示意图(1,1) (1,2) (1,3) (3,3) (3,2) (3,1) (2,1) (2 ,2) (2,3) (2,3) (2,2) (2,1)(3,1) (3,2) (3,3) (1,3) (1,2) (1 ,1)

可参考下面的范例原始魔方阵1,2拓朴变形魔方阵18 22 01 10 14 08 0412 25 16 04 08 12 16 25 22 18 01 14 10 15 19 23 02 06 19 15 23 06 02 21 05 0913 17 11 07 20 03 24 07 11 20 24 03 05 21 09 17 13注：其实对换变形、田字变形可包含于拓朴变形中，只因想法不同故列出参考

三、奇数阶魔方阵的建构法

1.杨辉法发明者：杨辉适用：三阶魔方阵方法：九子斜排，上下对易，左右相更，四维挺进

***1*** **4*2** 4 9 2 *7*5*3* 3 5 7 **8*6** 8 1 6 ***9***

杨辉法推广－菱形法发明者：Bachet de Meziriac适用：奇数阶魔方阵方法：数字斜排，上下对易，左右相更，四维挺进

********01******** ******06**02****** ? ? ? ****11**07**03*** * 11 24 07 20 03**16**12**08**04** 04 12 25 08 16 21**17**13**09**05 17 05 13 21 09 **22**18**14**10** 10 18 01 14 22 ****23**19**15**** ? 23 06 19 02 15 ******24**20******* *******25********

2.简捷连续填制法发明者：De La Loubere适用：奇数阶魔方阵方法：1立首列中，右一上一，受阻下一

* * 1 * * * * 1 * * * * 1 * * * * 1 * * * * 1 8 * 17 24 1 8 15 * * * * * * * ** * * 5 * * * * 5 * * * * 5 7 * * 23 5 7 14 16 * * * * * * * * * * 4 * * * * 46 * * * 4 6 * * * 4 6 13 20 22 * * * * * * * * * * * * * * 3 * * * * 3 10 * * *3 10 12 19 21 3 * * * * * * * * 2 * * * * 2 * * * * 2 * 11 * * 2 9 11 18 25 2 9简捷连续填制法推广适用：奇数阶魔方阵方法： (1)1立首列中，右1上1，受阻下1； (2)1立中央上，右1下2，受阻上2； (3 )1立首行中，右2下1，受阻右1； (4)1立首列中，右1下2，受阻下4； (5)1立中央上，右1上1，受阻上2 ； (6)1立首行中，左1上1，受阻右1。

3.辅助方阵法适用：五阶以上奇数阶魔方阵方法： (1)制作辅助方阵一：在左上端填入1，按照走马的方式往右二下一的方向填入1至底，接着在每列的1的右边依序填入2、3、4…n 1 * * * * 1 23 4 5 1 2 3 4 5 * * 1 * * * * 1 * * 4 5 1 2 3 * * * * 1 * * * * 1 2 3 4 5 1 * 1* * * * 1 * * * 5 1 2 3 4 * * * 1 * * * * 1 * 3 4 5 1 2 (2)制作辅助方阵二：在左上端填入0，按照走马的方式往右一下二的方向填入0至底，接着在每列的0的下面依序填入n、2n、3n…n(n-1) 0 * * ** 0 15 5 20 10 1 17 8 24 15 * * * 0 * 5 20 10 0 15 9 25 11 2 18 * 0 * * * 10 015 5 20 12 3 19 10 21 * * * * 0 15 5 20 10 0 20 6 22 13 4 * * 0 * * 20 10 0 155 23 14 5 16 7 (3)将辅助方阵一与二的对应方格内之数相加填到一个新的方阵对应方格内，则新的方阵即为一个魔方阵。

4.扩阶法适用：n阶魔方阵，n为大于5的正整数方法： (1)先建构出一个n-2阶的魔方阵(2)将(1)所建立的魔方阵每个数字再加上2n-2 (3)将步骤(2)的魔方阵外面再加上一圈，这一圈有4n-4个空格，填入的数为1~(2n-2)和( -2n+3)~n*n，先算出魔术数字会比较好填。

8 1 6 16 09 14 23 01 02 20 19 3 5 7 11 13 15 22 16 09 14 04 4 9 2 12 17 10 0511 13 15 21 08 12 17 10 18 07 25 24 06 03 5.方阵合成法适用：当魔方阵的阶数n可分解成两个大于2之整数p、q的乘积方法：假设A=[(a)ij]与B=[(b)ij]分别代表m阶与n阶魔方阵，对每个t=1，2…m*m，令At=[(a)ij+m*m(t–1)]。接着我们将方阵B中的数t以m阶魔方阵(A)t代替，就可以得到一个m． n阶魔方阵。

可参考下面的范例魔方阵A魔方阵B 35 28 33 26 19 24 71 64 69 8 1 6 4 3 830 32 34 21 23 25 66 68 70 3 5 7 9 5 1 31 36 29 22 27 20 67 72 65 4 9 2 2 7 680 73 78 44 37 42 08 01 06 75 77 79 39 41 43 03 05 07 A4 A3 A8 76 81 74 40 4538 04 09 02 A9 A5 A1 17 10 15 62 55 60 53 46 51 A2 A7 A6 12 14 16 57 59 61 4850 52 13 18 11 58 63 56 49 54 47

四、偶数阶魔方阵的建构法

1、杨辉法发明者：杨辉适用：4阶魔方阵方法：以十六子，依次递作四行排列，先以外四子对换，一换十六、四换十三，以四内角对换，六换十一、七换十，横直上下斜角，皆三十四数，对换止可施之于小。

01 02 03 04 16 02 03 13 16 02 03 13 05 06 07 08 05 06 07 08 05 11 10 08 09 1011 12 09 10 11 12 09 07 06 12 13 14 15 16 04 14 15 01 04 14 15 01

杨辉法推广－消去对角线法适用：四之倍数阶魔方阵方法： (1)先将整个方阵划分成k*k个4阶方阵，然后在每个4阶方阵的对角线上做记号( 2)由左而右、由上而下，遇到没有记号的位置才填数字，但不管是否填入数字，每移动一格数字都要加1 (3)自右下角开始，由右而左、由下而上，遇到没有数字的位置就填入数字，但每移动一格数字都要加1

2.井字法适用：四之倍数阶魔方阵方法： (1)把1~n*n从左上角依序填入方阵内(2)用两条铅直线和两条水平线将方阵分隔成四个角落各有一个n/4阶的子方阵，和中心位置有一个n/2阶的子方阵(3)以方阵中心为对称点，将五个子方阵的数字作对称交换，其它的数字不要动。这样的方阵会是一个魔方阵

01 02 03 04 16 02 03 13 05 06 07 08 05 06 07 08 09 10 11 12 09 10 11 12 13 1415 16 04 14 15 01

3.辅助方阵法适用：偶数阶魔方阵(因非四的倍数作法相当复杂，在此只介绍四的倍数的作法)方法： (1)制作辅助方阵一：第一列由左向右排列1至n，第二列由右向左排列1至n，第三列同第二列，第四列同第一列，若超过四列，重复一至四列的作法，完成辅助方阵一(2)制作辅助方阵二：将第一个辅助方阵各方格内的数字x换成n(x-1)，再做行列互换，完成辅助方阵二(3)将辅助方阵一与二的对应方格内之数相加填到一个新的方阵对应方格内，则新的方阵即为一个魔方阵01 02 03 04 00 1212 00 01 14 15 04 04 03 02 01 04 08 08 04 08 11 10 05 04 03 02 01 08 04 04 0812 07 06 09 01 02 03 04 12 00 00 12 13 02 03 16

4.扩阶法同奇数阶之作法

5.方阵合成法同奇数阶之作法

具体做法:

方法一；

/*此程序使我按照上面介绍的魔方阵的规律编写的,不过只能求奇数魔方阵,经过测试可以算到508阶*/
#define N 7
#include
void main()
{
  int a[N][N],i,j,k;
  for(i=0;i<n;i++)    *<="" span="" style="word-wrap: break-word;">先处理第一行*/
    for(j=0;j<n;j++)
     {
      a[i][j]=0;     /*先令所有元素都为0*/
    }
      j=(N-1)/2;     /*判断j的位置*/
      a[0][j]=1;    /*将1放在第一行中间一列*/
  for(k=2;k<=N*N;k++)    /*再从2开始处理*/
    {
      i=i-1;    /*存放的行比前一个数的行数减1*/
      j=j+1;    /*存放的列比前一个数的列数加1*/
      if((i<0)&&(j==N))   /*前一个数是第一行第N列时,把下一个数放在上一个数的下面*/
      {
        i=i+2;
        j=j-1;
      }
      else
      {
        if(i<0)    /*当行数减到第一行，返回到最后一行*/
        i=N-1;
        if(j>N-1)   /*当列数加到最后一行，返回到第一行*/
        j=0;
      }
      if(a[i][j]==0)     /*如果该元素为0,继续执行程序*/
        a[i][j]=k;
      else     /*如果该元素不为0,就说明要填的数的位置已经被占,则该数放在上一个数的下面*/
      {
        i=i+2;
        j=j-1;
        a[i][j]=k;
      }
    }
    for(i=0;i<n;i++)    *<="" span="" style="word-wrap: break-word;">输出数组*/
    {
      for(j=0;j<n;j++)
       printf("%5d",a[i][j]);
      printf("\n\n");
    }
  }

方法二:

/*这个是网友qfyzy为帮助我找错而提供的,可以算到99阶*/
#define N 7
#include
void main()
{
    int a[N][N]={0},i=0,j,k;     /*先令所有元素都为0*/
      j=(N-1)/2;
      i=0;
  for(k=1;k<=N*N;)    /*开始处理*/
    {
      if((i<0)&&(j==N))   /*前一个数是第一行第N列时,把下一个数放在上一个数的下面*/
      {
        i=i+2;
        j=j-1;
      }
      else  if(i<0)   /*当行数减到第一行，返回到最后一行*/
       i=N-1;
      else  if(j>N-1)   /*当列数加到最后一行，返回到第一行*/
        j=0;
      else  if(!a[i][j]){     /*如果该元素为0,继续执行程序*/
        a[i][j]=k++;
        i=i-1;
        j=j+1;
      }
      else     /*如果该元素不为0,就说明要填的数的位置已经被占,则该数放在上一个数的下面*/
      {
        i=i+2;
        j=j-1;
      }
    }
    for(i=0;i<n;i++)    *<="" span="" style="word-wrap: break-word;">输出数组*/
    {
      for(j=0;j<n;j++)
       printf("%5d",a[i][j]);
      printf("\n\n");
    }
  }

方法三:

/*此程序是在网上找到的c程序设计习题7.7的答案,只能算奇数阵,可以算到15阶*/
#include
void main()
{int a[16][16],i,j,k,p,m,n;
p=1;
while(p==1)
   {printf("请输入阶数:");   /*原答案没有这个输出语句*/
     scanf("%d",&n);
    if((n!=0)&&(n<=15)&&(n%2!=0))p=0;
   }
for(i=1;i<=n;i++)
   for(j=1;j<=n;j++)
     a[i][j]=0;
j=n/2+1;
a[1][j]=1;
for(k=2;k<=n*n;k++)
   {i=i-1;
    j=j+1;
    if((i<1)&&(j>n))
      {i=i+2;
       j=j-1;
      }
    else
      {if(i<1)i=n;
       if(j>n)j=1;
      }
    if(a[i][j]==0)a[i][j]=k;
    else
      {i=i+2;
       j=j-1;
       a[i][j]=k;
      }
    }
for(i=1;i<=n;i++)
   {for(j=1;j<=n;j++)
      printf("%3d",a[i][j]);
    printf("\n");
   }
}

方法四:
/*这个是我找到的功能最强大的求魔方阵的程序,奇、偶阵都可以求，可以多次测试，最大阶可以自己设定（我测试的最大设定值是507，此时可以运行到506阶，不过也可以设定到508，但是这时真正运行的时候却达不到506阶）*/
#include
#include
#include
#include
#define MAX_INDEX 100 /*这里可以修改最大阶*/

void swap(int *a,int *b)
{
int t;
t=*a;
*a=*b;
*b=t;
}

/*快速排序算法*/
void QuickSort(int a[], int l, int r)

{
int i=l; /*从左至右的游标*/
int j=r + 1; /*从右到左的游标*/
int pivot=a[l];
if (l >= r) return;
/*把左侧>= pivot的元素与右侧<= pivot 的元素进行交换*/
while (1)
{
do
{/*在左侧寻找>= pivot 的元素*/
i = i + 1;
} while (a[i] < pivot);
do
{/*在右侧寻找<= pivot 的元素*/
j = j - 1;
} while (a[j] > pivot);
if (i >= j) break; /*未发现交换对象*/
swap(&a[i],&a[j]);
}

/*设置p i v o t*/
a[l] = a[j];
a[j] = pivot;
QuickSort(a, l, j-1); /*对左段排序*/
QuickSort(a, j+1, r); /*对右段排序*/
}

void Huanf(int Array[][MAX_INDEX],int n)
{
int i,j;
int a,b,m;
int tempArray1[MAX_INDEX];
int tempArray2[MAX_INDEX];
a=n/2;
b=a+1;
m=n%4;
switch(m)
{
case 0:
case 2:
/*穿心对调*/
for(i=0;i<n;i++)
for(j=0;j<n 2;j++)
{
if(i<n 2)
{
if(i%2==1&&Array[i][j]%2==0)/*偶行换偶*/
{
swap(&Array[i][j],&Array[n-1-i][n-1-j]);
}
else if(i%2==0&&Array[i][j]%2==1)/*奇行换奇*/
{
swap(&Array[i][j],&Array[n-1-i][n-1-j]);
}
}
else
{
if(i%2==1&&Array[i][j]%2==1)/*偶行换奇*/
{
swap(&Array[i][j],&Array[n-1-i][n-1-j]);
}
else if(i%2==0&&Array[i][j]%2==0)/*奇行换偶*/
{
swap(&Array[i][j],&Array[n-1-i][n-1-j]);
}
}

}
/*End穿心对调*/
if(m==2)
{
for(i=0;i<n 2;i++)
{
if((i!=0)&&(i!=a-1)&&(i!=b-1)&&(i!=n-1))
{
swap(&Array[i][a-1],&Array[n-1-i][a-1]);
swap(&Array[b-1][i],&Array[b-1][n-1-i]);
}
}
swap(&Array[0][a-1],&Array[0][b-1]);
swap(&Array[a-1][0],&Array[b-1][0]);
swap(&Array[2][0],&Array[2][n-1]);
swap(&Array[0][2],&Array[n-1][2]);
}
break;
case 1:
case 3:
/*穿心对调*/
for(i=0;i<n;i++)
for(j=0;j<n 2;j++)
{
if(i<n 2)
{
if(i%2==1&&Array[i][j]%2==0) /*偶行换偶*/
{
swap(&Array[i][j],&Array[n-1-i][n-1-j]);
}
else if(i%2==0&&Array[i][j]%2==0)/*奇行换奇*/
{
swap(&Array[i][j],&Array[n-1-i][n-1-j]);
}
}
else if(i>n/2)
{
if(i%2==1&&Array[i][j]%2==0)/*偶行换偶*/
{
swap(&Array[i][j],&Array[n-1-i][n-1-j]);
}
else if(i%2==0&&Array[i][j]%2==0)/*奇行换奇*/
{
swap(&Array[i][j],&Array[n-1-i][n-1-j]);
}
}
}
/*End穿心对调*/
/*重排米字*/
for(i=0;i<n;i++)
{
tempArray1[i]=Array[i][i];
tempArray2[i]=Array[a][i];
}

QuickSort(tempArray1,0,n-1);
QuickSort(tempArray2,0,n-1);
for(i=0;i<n;i++)
{
Array[i][i]=tempArray2[i];
Array[a][i]=tempArray1[i];
}
for(i=0;i<n;i++)
{
tempArray1[i]=Array[i][n-1-i];
tempArray2[i]=Array[i][a];
}
QuickSort(tempArray1,0,n-1);
QuickSort(tempArray2,0,n-1);
for(i=0;i<n;i++)
{
Array[i][n-1-i]=tempArray2[i];
Array[i][a]=tempArray1[i];
}
/*End重排米字*/

if(m==3)
{
for(i=0;i<n 2;i++)
{
if((i!=a-1)&&(i!=b-1)&&(i!=a+1))
{
swap(&Array[i][a-1],&Array[n-1-i][a-1]);
swap(&Array[a-1][i],&Array[a-1][n-1-i]);
}
}
swap(&Array[a-1][a-1],&Array[a+1][a+1]);
swap(&Array[a-1][b-1],&Array[a+1][b-1]);
}
break;
default:
break;
}
return;
}

void main()
{
int Ne[MAX_INDEX][MAX_INDEX];
int i,j,n;
while(1)
{
printf("Please Input N (0 quit): \n");
scanf("%d",&n);
if(n==0)
break;

/*数组赋初值*/
for(i=0;i<n;i++)
for(j=0;j<n;j++)
Ne[i][j]=i*n+(j+1);

Huanf(Ne,n);

for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
printf("%-4d",Ne[i][j]);
if(j==n-1)
printf("\n");
}
printf("\n");
getch();
}
}

方法五：

/*相比方法四的程序，这个程序更加简洁，唯一的缺陷是只能求奇数魔方阵，也可以多次测试，最大阶可以自己设定（我测试的最大设定值是507，此时也可以运行到507阶）*/
#include
#include
#define MAXSIZE 21 /*这里可以修改最大阶*/

void main(void)
{
int matrix[MAXSIZE][MAXSIZE]; /* the magic square */
int count; /* 1..n*n counting */
int row; /* row index */
int column; /* column index */
int order; /* input order */
char line[100];
do{
system("cls");
printf("\n\t\t\t 奇数阶魔方阵(输入1退出程序)");
printf("\n\t\t\t======================================");
printf("\n\n请输入一个小于等于%d的奇数:",MAXSIZE);
gets(line);
order=atoi(line);
if(order==1)
exit(0);
if (order>MAXSIZE)
printf("\n\t\t*** Error *** 输入的奇数 <%d\n",MAXSIZE);
else if (order%2==0)
printf("\n\t\t*** Error *** 输入的必须是奇数!!!\n");
else
{
row=0; /* start of from the middle */
column=order/2; /* of the first row. */
for (count=1;count<=order*order; count++)
{
matrix[row][column] = count; /* put next # */
if (count % order == 0) /* move down ? */
row++; /* YES, move down one row */
else
{ /* compute next indices */
row = (row == 0) ? order - 1 : row - 1;
column = (column == order-1) ? 0 : column + 1;
}
}
printf("\n\n%d阶魔方阵如下:\n\n", order);
for (row=0; row < order; row++)
{
for (column = 0; column < order; column++)
printf("%4d", matrix[row][column]);
printf("\n");
}
}
system("pause");
}while(order!=1);
}

方法六：

/*这个程序的功能也很强大,奇、偶阵都可以求，最大阶可以自己设定（我测试的最大设定值是508，此时可以运行到508阶）*/
#include
#include
#define MAX_NUM 15    /*这里可以修改最大阶*/
int main()
{
    int rows = 0, center = 0, iArray[MAX_NUM][MAX_NUM];
    int RowSet = 0, LineSet = 0, newRowSet = 0, newLineSet = 0;
    int i = 0, j = 0;
    int okNum = 0;

    // set the items of array "iArray" to be 0
    for ( i = 0; i < MAX_NUM; i++ )
        for ( j = 0; j < MAX_NUM;j++ )
            iArray[i][j]= 0;

    // get the rows number
    while ( 1 )
    {
        printf("输入行数:\n");
        scanf("%d",&rows);
        if ( rows <= MAX_NUM )
        {
               rows -= 1;
               break;
        }
        else {
            printf("行数必须在 0 和 %d 之间, 请重新", MAX_NUM);
        }
    }

    // set number '1'
    center = rows / 2;
    iArray[0][center] = 1;

    // initialize the okNum, RowSet and LineSet
    okNum = 1;
    RowSet = 0;
    LineSet = center;

    // set each item in "iArray"
    while ( okNum < (rows + 1) * (rows + 1) )
    {
          if ( RowSet == 0&& LineSet == rows )
          {
               RowSet+= 1;
          }
          else {
                    newRowSet= (RowSet == 0) ? rows : RowSet - 1;
                    newLineSet= (LineSet == rows) ? 0 : LineSet +1;

                  if ( iArray[newRowSet][newLineSet] != 0 )
                  // there is already a number here!
                  {
                           RowSet = (RowSet == rows) ? 0 : RowSet + 1;
                           //RowSet += 1;
                  }
                  else{
                           RowSet = newRowSet;
                           LineSet = newLineSet;
                  }
          }

          iArray[RowSet][LineSet]= ++okNum;
    }

    // print the "iArray"
    for ( i = 0; i <= rows; i++ )
    {
        for ( j = 0; j <= rows; j++)
            printf("%5d",iArray[i][j]);
        printf("\n");
    }

    system("pause");
    return 0;
}

方法七：

/*此程序可以运行到508阶魔方阵*/
#define N (int)5    /*这里可以修改最大阶*/
#include
void main()
{
int i,k,c;
int m[N][N]={0};
i=0; k=N/2;

    for(c=1;c<=N*N;c++)

{
     if(m[i][k]!=0)
     {

         i++;
         if(i>N-1)i=0;
          i++;
        if(i>N-1)i=0;

          k--;
        if(k<0)k=N-1;
      }

    m[i][k]=c;
        i--;k++;
    if(i<0)i=N-1;
    if(k>N-1)k=0;

}

printf(" %d 阶魔方阵:\n\n",N);

for(i=0;i<n;i++)
{
   for(k=0;k<n;k++)
     printf("%4d",m[i][k]);
   printf("\n");
}

}

方法八：

/*此程序可以运行3阶到15阶奇数阵*/
#include
#define N 15

int main(void)
{
int i,j,row,cloum,size,square[N][N],count;
printf("please enter the square size(odd && <=15):\n");
scanf("%d",&size);
while(size%2==0||size>15||size<3)
{
printf("error due to the wrng input!please input it again!\n");
scanf("%d",&size);
}
for(i=0;i<size;i++)
for(j=0;j<size;j++)
square[i][j]=0;
i=0;
j=(size-1)/2;
square[i][j]=1;
for(count=2;count<=size*size;count++)
{
row=i-1<0?(size-1):(i-1);
cloum=j-1<0?(size-1):(j-1);
if(square[row][cloum])
i=(++i)%size;
else
{
i=row;
j=j-1<0?(size-1):(j-1);
}
square[i][j]=count;
}
printf("the %d square is:\n",size);
for(i=0;i<size;i++)
{
for(j=0;j<size;j++)
printf("%5d",square[i][j]);
printf("\n");
}

getchar();
getchar();
return 0;
}

方法九：

/*此程序由行矩阵、列矩阵和自然矩阵计算魔方阵的，可以运行到359阶魔方阵*/
#include "stdio.h"
#define N 7 /*这里可以修改最大阶*/
main()
{
int col[N][N],row[N][N];
int i,j;
/*求行矩阵*/
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
col[i][j]=(-1)*i+j+(N+1)/2;
if(col[i][j]>N)
col[i][j]-=N;
if(col[i][j]<1)
col[i][j]+=N;
}
}
/*求列矩阵*/
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
row[i][j]=col[i][N-j-1];
}
}
/*由行矩阵、列矩阵和自然矩阵计算魔方阵*/
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("%5d",(col[i][j]-1)*N+row[i][j]);
}
printf("\n");
}
}