从外向内的旋转数组输出

题目描述如下图：

 

解法一：

使用一个二维数组存储结果二维数组，然后输出此二维数组。时间复杂度O(n*n),空间复杂度O(n*n)，此解法的C++代码如下：

#include<iostream>
using namespace std;

int main()
{
    int side_long;    //矩阵的边长
    cout<<"please input the length of edge"<<endl;
    cin>>side_long;
    int number_of_elements=side_long*side_long; 
    int* result_array=(int*)malloc(number_of_elements*sizeof(int));   //用于存储二维数组
    int count=side_long-1;    //count代表从外圈到内圈的过程中，当前圈的边长
    int steps=1,i=0,j=0;     //steps表示当前遍历了多少个元素
    while(steps<=number_of_elements)
    {
        for(int right=0;right<count;right++)           //在当前圈，向右遍历count个元素
        {
            *(result_array+i*side_long+j++)=steps++;
            if(steps>number_of_elements)
                break;
        }
        for(int down=0;down<count;down++)    //在当前圈，向下遍历count个元素
        {
            *(result_array+(i++)*side_long+j)=steps++;
            if(steps>number_of_elements)
                break;
        }
        for(int left=0;left<count;left++)    //在当前圈，向左遍历count个元素
        {
            *(result_array+i*side_long+j--)=steps++;
            if(steps>number_of_elements)
                break;
        }
        for(int up=0;up<count-1;up++)    //在当前圈，向上遍历count-1个元素
        {
            *(result_array+(i--)*side_long+j)=steps++;
            if(steps>number_of_elements)
                break;
        }
        *(result_array+i*side_long+j)=steps++;   //遍历当前圈的最后一个元素
        if(steps>number_of_elements)
            break;
        j++;
        count=count-2;    //向内圈转移
    }

    for(i=0;i<side_long;i++)   //输出最终的二维数组
    {
        for(j=0;j<side_long;j++)
        {
            cout<<"\t"<<*(result_array+i*side_long+j);
        }
        cout<<endl;
    }
    free(result_array);
    return 0;
}

 

解法二：

根据元素在二维矩阵中的位置索引来计算某个位置的值。不用存储二维结果数组，在从上到下，从左到右计算遍历某个位置时计算出该位置的值，并输出。时间复杂度O(n*n)，空间复杂度O(1)。Python代码如下：

length_of_edge=input("Please input the length of edge:")   #矩阵边长的长度
max_perimeter=4*length_of_edge-4   #最外层圈的边长
for i in range(0,length_of_edge):
    for j in range(0,length_of_edge):   #遍历二维矩阵的每个位置(i,j)
        if i+j<=length_of_edge-1:      #副对角线线的左上方
            if i<=j:
                min=i
            else:
                min=j
            if min==0:
                front_perimeters=0  #front_perimeter代表当前位置所在圈之外那些圈边长的和
            else:
                front_perimeters=(2*max_perimeter-(min-1)*8)*min/2
            if(min==i):
                this_perimeter=j-i+1    #this_perimeter从当前圈的第一个元素（左上）开始到当前元素一共有多少个元素
            else:
                this_perimeter=max_perimeter-8*min-(i-j-1)
            number=front_perimeters+this_perimeter
            print "\t",number,
        else:   #副对角线的右下方
            if j>=i:
                max=j
            else:
                max=i
            if max==length_of_edge-1:
                front_perimeters=0
            else:
                front_perimeters=(2*max_perimeter-(length_of_edge-1-max-1)*8)*(length_of_edge-1-max)/2
            if(max==j):
                this_perimeter=length_of_edge-2*(length_of_edge-1-max)+(i+1)-(length_of_edge-1-max+1)
            else:
                this_perimeter=2*(length_of_edge-2*(length_of_edge-1-max)-1)+(length_of_edge-j-(length_of_edge-1-max))
            number=front_perimeters+this_perimeter
            print "\t",number,
    print