输入一个整数n(0
标准输出

输出一个n*n的旋转方阵，数字以顺时针方向逐渐增大，输出的每个整数宽度为4，且右对齐
范例输入

5
范例输出

   0   1   2   3   4
  15  16  17  18   5
  14  23  24  19   6
  13  22  21  20   7
  12  11  10   9   8
这道题目是测试题，考试已经过去了，我抄下来后，实在想不出，想请大伙教教我。谢谢

搜一搜  这个本论坛有很多很多现成的代码

我上百度搜了很多，我很想知道思路。

很想用文字描述一下思路的，写了半天发现原来用代码才是最清晰的描述方式。对于这种小到不能再小的功能，看代码绝对比看文字来得好。如果你连这种程度的代码都看不懂，那说明你基础还没学好。请原谅我说了实话。

好的  知道了 谢谢

旋转输出规律很难找，没细想，建议使用二维数组

#include <stdio.h>
#include <stdlib.h>
#define PV *(p + n * i + j)
#define OVERODD *(p + (n/2) * n + (n/2)) = (n * n) - 1
#define SQUR val = right(*(prep+i), step_len, val, p)
#define SQUD val = down(*(prep+i), step_len, val, p)
#define SQUL val = left(*(prep+i), step_len, val, p)
#define SQUU val = up(*(prep+i), step_len, val, p)
#define SQU SQUR;SQUD;SQUL;SQUU;

int n;
void new_num(int, int *);
int right(int, int, int, int *);
int down(int, int, int, int *);
int left(int, int, int, int *);
int up(int, int, int, int *);
void prt_num(int, int *);

int main(void)
{
    int i, num[1], *p_num, INITnum[4] = { 0, 1, 3, 2 };
    p_num = (int *)num;
  L1:
    printf("请输入右内旋矩阵的基数: ");
    scanf("%d", &n);
    if (n <= 1)
    {
        printf("输入不合法...");
        goto L1;
    }
    if (n == 2)
    {
        printf("\n");
        for (i = 0; i < 4; i++)
        {
            printf("%4d ", INITnum[i]);
            if ((i + 1) % 2 == 0)
            {
                printf("\n");
            }
        }
        printf("\n");;
    }
    if (n > 2)
    {
        p_num = malloc(n * n * sizeof(int));
        new_num(n, p_num);
        prt_num(n, p_num);
        free(p_num);
    }
    return 0;
}

void new_num(int n, int *p)
{
    int step_len = n - 1;
    int step_rep = (n - 1) / 2;
    int val = 0;
    int i;
    int rep[1], *prep;
    prep = rep;
    prep = malloc(step_rep * sizeof(int));

    for (i = 0; i < step_rep; i++)
    {
        *(prep + i) = i;
    }
    if (n % 2 == 0 && n > 3)
    {
        i = 0;
        for (; step_rep > 0; step_rep--)
        {
            SQU
            i++;
            step_len--;
        }
        *(p + n * (n / 2 - 1) + n / 2 - 1) = n * n - 4;
        *(p + n * (n / 2 - 1) + n / 2) = n * n - 3;
        *(p + n * n / 2 + n / 2) = n * n - 2;
        *(p + n * n / 2 + n / 2 - 1) = n * n - 1;
    }
    else
    {
        i = 0;
        for (; step_rep > 0; step_rep--)
        {
            SQU
            i++;
            step_len--;
        }
        OVERODD;
    }
    free(prep);
}

int right(int rep, int len, int v, int *p)
{
    int i = rep;
    int j = rep;
    for (; j < len; j++)
    {
        PV = v++;
    }
    return v;
}
int down(int rep, int len, int v, int *p)
{
    int i = rep;
    int j = n - 1 - rep;
    for (; i < len; i++)
    {
        PV = v++;
    }
    return v;
}
int left(int rep, int len, int v, int *p)
{
    int i = n - 1 - rep;
    int j = n - 1 - rep;
    for (; j > rep; j--)
    {
        PV = v++;
    }
    return v;
}
int up(int rep, int len, int v, int *p)
{
    int i = n - 1 - rep;
    int j = rep;
    for (; i > rep; i--)
    {
        PV = v++;
    }
    return v;
}

void prt_num(int n, int *prt)
{
    int i;
    printf("\n");
    for (i = 0; i < n * n; i++)
    {
        printf("%4d ", *(prt + i));
        if ((i + 1) % n == 0)
        {
            printf("\n");
        }
    }
    printf("\n");
}

[ 本帖最后由 longwu9t 于 2014-11-25 22:04 编辑 ]

大侠，能描述下思路吗

我不是大侠，初学C刚一个多月，上面的代码是我一步步找数字旋转排列的规律，然后再推导出来的，其实就是一个个正方形向中心收缩。
写完这段代码后，我又找了一下网上的资料，发现我的实现其实是最笨拙的一种。
而且代码写的也不简洁，不过其中一个主要的制约是考虑到矩阵基数是不定长的，VS2010的C编译器又不让用变量定义数组的长，
虽然GCC之类的支持C99的编译器允许，但为了程序通用性，使用了指针来动态分配内存，这又导致了变量定义过多。
反正这段程序写完后我不满意，修改了多遍，由于根子上是算法太差，所以也没太多的改善，为了程序看起来简洁些，没办法用了define

实在是功力不足啊……

我前几天写了一个C++的 算法是一样的 只不过C++用了容器 C语言可以用数组 一样的

我是算法是这样的 方阵的生成 无非是从四个方向走的 ①从左到右 ②从上到下 ③从右到左 ④从下到上 找出规律 依次以这四种方式往里面填数就好了