大家好，我是诚挚的乔治

 前言：

本次蛇形矩阵我将以两种方法来实现，即非递归和递归

非递归的实现：

#define right 1
#define down 2
#define left 3
#define up 4
#define n 5     //控制矩形的大小
#include<stdio.h>
int main()//设计一个蛇形矩形图案 顺时针
{
	int m = 1; int x = 1; int y = 1; int direct; int i = 0;
	int j = 0;
	int arr[n + 1][n + 1];
	for (x = 1; x < (n + 1); x++)
	{
		for (y = 1; y < (n + 1); y++)
		{
			arr[x][y] = 100;//随机但是不能定为零
		}
	}
	x = 1; y = 1; direct = right;
	while (m <= n * n)
	{
		arr[x][y] = m++;
		switch (direct)
		{
		case right:
			if (arr[x][y + 1] == 100)
			{
				y++;
			}
			else
			{
				direct = down;
				x++;
			}break;
		case down:
			if (arr[x + 1][y] == 100)
			{
				x++;
			}
			else
			{
				direct = left;
				y--;
			}break;

		case left:
			if (arr[x][y - 1] == 100)
			{
				y--;
			}
			else
			{
				direct = up;
				x--;
			}break;
		case up:
			if (arr[x - 1][y] == 100)
			{
				x--;
			}
			else
			{
				direct = right;
				y++;
			}break;
		}
	}
	//显示矩形
	for (x = 1; x <= n; x++)
	{
		for (y = 1; y <= n; y++)
		{
			printf("%2d ", arr[x][y]);
		}
		printf("\n");
	}
	return 0;
}

非递归的解题思想：定义一个数组，这个数组的大小是（N+1）*（N+1），目的是形成一个边框，便于调整方向，其次就是当x与y跑到边框的位置就实现拐弯。

拐弯的思想就是上到下，下到左，左到上，上再到右，实现从外围向内包围，直至m <= n * n。

递归的实现：

#define right 1
#define down 2
#define left 3
#define up 4
#define n 7          //控制大小
int arr[n][n];
#include<stdio.h>
void snake(int x, int y, int m, int direct)
    {
      arr[x][y]=m;
  	if (m == n * n)
		return;
 	switch (direct)
	{
	case right:
 		if ((y+1) == (n+1) || arr[x][y+1] > 0)

		{//到达右边边界或者右边有数字，不能再往右
			direct = down; //改变方向，向下
			x++; //向下移动一格
		}
		else     //可以向右填写
   			y++; //向右移动一格
		break;
	case down:
		if ((x + 1) == (n+1) || arr[x + 1][y] > 0)
		{
			direct = left;
			y--;
		}
		else
			x++;
		break;
	case left:
		if ((y + 1) == (n+1) || arr[x][y - 1] > 0)
		{
			direct = up;
			x--;
		}
		else
			y--;
		break;
	case up:
		if ((y + 1) == (n+1) || arr[x-1][y] > 0)
		{
			direct = right;
			y++;
		}
		else
			x--;
		break;
	}
    	snake(x, y, ++m, direct); //填写下一个数
}
int main()//用递归填写这个矩形蛇形图案
 {
	int x = 1; int y = 1; int m = 1;
 	snake(x, y, m, right);
	//显示矩形
	for (x = 1; x <= n; x++)
	{
 		for (y = 1; y <= n; y++)
		{
 			printf("%2d ", arr[x][y]);//这里有个二，别忘了
 		}
		printf("\n");
	}
	return 0;
}

递归的实现大体思路跟非递归的实现类似，从外面到内部

但递归的每一个元素是单独在一个函数里来定义的，直至最后的m==n*n，然后再main函数里实现最终的模型。

其中的n是来控制大小，例如当n为5和9的结果如下：

欢迎点赞收藏加关注，如若有问题可以题出来😁😁😁😁

蛇形矩阵

#include<stdio.h>
/*输出蛇形矩阵*/
int main()
{
    int n;
    int num[100][100];
    int i=0,j=0;
    int count = 0;
    scanf("%d",&n);
    num[i][j]=++count;//为num[0][0]赋值1
    while(count<n*n)
    {
        if(j<n-1)//if-else语句判断是横着走一个还是竖着走一个，并赋值
            j++;
        else
            i++;
        num[i][j]=++count;
        while(i<n-1&&j>0)//斜向下走，直到走到头
        {
            i++;j--;
            num[i][j]=++count;
        }
        if(i<n-1)//if-else语句判断是横着走还是竖着走，并赋值
            i++;
        else
            j++;
        num[i][j]=++count;
        while(i>0&&j<n-1)//斜向上走，走到头
        {
            i--;j++;
            num[i][j]=++count;
        }
         
    }
    for(i=0;i<n;i++)//输出
    {
        for(j=0;j<n;j++)
            printf("%d ",num[i][j]);
        putchar('\n');
    }
return 0;
}

回形矩阵

#include<stdio.h>
/*输出回形矩阵*/
int main()
{
    int n,count=0,i;
    scanf("%d",&n);
    int num[100][100];
    int start=0,finish=n-1;
    while(count<n*n)
    {
        
        for(i=start;i<=finish;i++)//从左向右
            num[start][i]=++count;
        for(i=start+1;i<=finish;i++)//从上到下
            num[i][finish]=++count;
        for(i=finish-1;i>=start;i--)//从右往左
            num[finish][i]=++count;
        for(i=finish-1;i>=start+1;i--)//从下向上
            num[i][start]=++count;
        start++;finish--;//缩圈
    }
    for(i=0;i<n;i++)//输出
    {
        for(int j=0;j<n;j++)
            printf("%d ",num[i][j]);
        putchar('\n');
    }
    return 0;
}

开始的时候遇到了问题：Process returned -1073741571 (0xC00000FD)

发现原因是num[1000][1000]定义的太大了内存溢出，改小一点就好啦

输入任意阶数，即可打对应印蛇形矩阵。原理是根据蛇形矩阵的性质，运用矩阵行列对下个数字打印的方向进行判别，从而打印出对应的数字。详情请看如下参考代码。

参考代码：

#include<stdio.h>
int n;
int i = 0;  //行  
int j = 0;  //列  
int k = 1;  //运动方向. k =1 →;  k=2 ↙； k=3 ↓ ；k=4 ↗
int data[100][100];

int main()
{
	printf("输入矩阵阶数:\n");
	scanf_s("%d", &n);
	//------------------判断方向
	while (i != n - 1 || j != n - 1)
	{
		if (k == 1) 
		{
			data[i][j + 1] = data[i][j] + 1;
			j++;
			if (i == n - 1) 
			{
				k = 4;
			}
			else
			{
				k = 2;
			}
		}
		else if (k == 2) 
		{
			data[i + 1][j - 1] = data[i][j] + 1;
			j--;
			i++;
			if (j == 0 && i != n - 1)
			{
				k = 3;
			}
			else if (i == n - 1) 
			{
				k = 1;
			}
			else 
			{
				k = 2;
			}
		}
		else if (k == 3) 
		{
			data[i + 1][j] = data[i][j] + 1;
			i++;
			if (j == n - 1) 
			{
				k = 2;
			}
			else 
			{
				k = 4;
			}
		}
		//-------------------------生成矩阵元素
		else if (k == 4) 
		{
			data[i - 1][j + 1] = data[i][j] + 1;
			j++;
			i--;

			if (i == 0 && j != n - 1)
			{
				k = 1;
			}
			else if (j == n - 1)
			{
				k = 3;
			}
			else 
			{
				k = 4;
			}
		}
	}
	//显示矩阵  
	for (int a = 0; a < n; a++) 
	{
		for (int b = 0; b < n; b++) 
		{
			printf("%d\t", data[a][b]);
		}
		printf("\n");
		printf("\n");
	}
}

运行结果：