看热闹来了

①说明思路:
    三维立体螺旋矩阵通过变长二维数组实现，矩阵中最小数为1，最大数根据边长不同而不同。
    第一步，先初始化二维数组为全0，为后面打印做准备
    第二部，判断边长是奇是偶，为三维螺旋矩阵正面最后一步赋值做准备
    第三步，利用三层循环给二维数组赋值，其中最里面一层为多个for循环，分别为矩阵上边右边下边左边赋值
    第四步，利用双重循环打印三维螺旋矩阵图
②程序代码:
#include<stdio.h>
//屏幕太小，边长只到30，原则上任意边长都行
int main()
{
    int i,j,p,q,n,m,k,x;
    printf("请输入螺旋矩阵的边长(30之内):");
    scanf("%d",&n);
    int a[2*n-1][2*n-1];

    for(i=0;i<2*n-1;i++)//初始化二维数组为全0
    {
        for(j=0;j<2*n-1;j++)
        {
            a[i][j]=0;
        }
    }

    if(n%2==0)//判断奇数偶数
    {
        m=n/2;//偶数
    }
    else
    {
        m=n/2+1;//奇数
    }

    for(x=0;x<n;x++)//二维数组赋值实现三维螺旋矩阵图
    {
        for(k=x+1,p=0,q=x;p<m;p++)
        {
            i=p+n-1-q;
            j=p+q;
            if(n%2!=0&&p==m-1)//奇数最后一个数
            {
                a[i][j]=k;
                break;
            }
            for(;j<n-1-p+q;j++,k++)//上边
            {
                a[i][j]=k;
            }
            for(;i<n*2-1-q-1-p;i++,k++)//右边
            {
                a[i][j]=k;
            }
            if(x>0)//非矩阵正面，只打印上右两边
            {
                a[i++][j]=k++;
                break;
            }
            for(;j>0+p;j--,k++)//下边
            {
                a[i][j]=k;
            }
            for(;i>n-1+p;i--,k++)//左边
            {
                a[i][j]=k;
            }
        }
    }

    for(i=0;i<2*n-1;i++)//打印
    {
        for(j=0;j<n*2-1;j++)
        {
            if(a[i][j]==0)
            {   
                printf("   ");
            }
            else if(j>=2*n-1-1-i&&j>=n-1)
            {
                printf("%-3d",a[i][j]);
            }
            else
            {
                printf("%-4d",a[i][j]);
            }
        }
        printf("\n");
    }
    return 0;
}
③测试效果图:






希望大家有更好的实现方式！

[ 本帖最后由 小小战士 于 2012-12-12 15:13 编辑 ]

真好看

呵呵，我猜也是这种方法。

算了不卖关子了，展示一下我的代码。IE在这里发图片有点问题，有兴趣的自己执行一下吧。

cal函数不仅可以计算cube的表面，也可以计算其内部任何位置的值。

当然，这个cube的侧面可以用更简单的方法显示，这里为了演示cube函数的功能就所有位置的值都用它计算了。

数值的间距程序可以自己计算，保证两个相邻数值之间至少有一个空格。

#include<stdio.h>
#include<math.h>

int cal(int n, int r, int c, int y)
{
    int t, t1;
    n--;
    t = r < c ? (t1 = n - c , r) : (t1 = n - r, c);
    t = t < t1 ? t : t1;
    y += 4 * (n - t + 1) * t;
    return y + 1 + (r <= c ? r + c - t - t : n * 4 - t * 6 - r - c);
}

void show_cube(int n)
{
    int i, j, k, d;
    d = log10(n * n) + 1;
    if(d == log10(n * 2) + 1) d++;
    for(k = n - 1, i = 0; i < n; puts(""), k ? k-- : i++)
    {
        for(j = 0; j < k; j++) printf("%*c", d, ' ');
        for(j = 0; j < n - 1; j++) printf("%-*d", d + 1, cal(n, i, j, k));
        printf("%-*d", d, cal(n, i, j, k));
        for(j = 1; j < n - k - i; j++) printf("%-*d", d, cal(n, i + j, n - 1, k + j));
    }
}

int main()
{
    int n;
    printf("input n: ");
    scanf("%d", &n);
    show_cube(n);
    return 0;
}

学习都无法学习  复杂度O（N^M）

哦？老哥是怎么得出复杂度是O(N*M)这个结论的？M是什么？

其实它的时间复杂度是O(1)。

输出部分其实是两层嵌套循环，内部的三个循环只是控制输出的三种不同格式部分，它们是并列的。

输出无论在哪儿也省不下的，这部分不应计入算法的时间复杂度内。

我的算法的优势在这里并不明显，但要是换个问法你就会发现了。

比如，输出从这个立方体上裁出一块的小立方体（或者长方体）的表面数值。

实例，将一个10000 X 10000 的立方体上下左右前后各而裁去4595层后，剩下的10 X 10的立方体的表面数值。

呵呵，我的是N的M次幂 可不是N*M 这里代表无穷大的意思

换句话就是说，你的代码或者思想 暂时我还理解不了

呵呵，O这在里是专有符号，空间复杂度用S。你这该算是理解复杂度吧，建议用U。

今天刚刚翻出来算法书  for delphi的
当初获得时（电子书，打印的，又封装的）很激动

现在看来  很不好  好多算法都封装了类  而我暂时又不想学c++  
于是乎 又变成了鸡肋

封装的只是接口，算法的本真在函数内部。

事实上当你的程序越做越大时，面向对象的优势会越来越明显。

没跟老哥说过吧，其实我更擅长的是C#，发在论坛里涉及图形界面的程序都是用C#写的。