剑指offer面试题：输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字

题目:输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字。

输入一个矩阵如下:

 1     2     3    4

 5     6     7    8

 9    10   11  12

 13  14   15  16

则依次打印出数字:1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10

解析：由于题目是以从外圈到内圈的顺序依次打印，在矩阵中标注一圈作为分析的目标。设矩阵的宽度为cols，而其高度为rows。选取左上角坐标为(startX, startY)，右下角坐标为(endX, endY)的一个圈来分析。

 


      由于endX和endY可以根据startX、startY以及columns、rows来求得，因此此时我们只需要引入startX和startY两个变量。我们可以想象有一个循环，在每一次循环里我们从(startX, startY)出发按照顺时针打印数字。

      接着分析这个循环结束的条件。对一个5×5的矩阵而言，最后一圈只有一个数字，对应的坐标为(2, 2)。我们发现5 > 2 * 2。对一个6×6的矩阵而言，最后一圈有四个数字，对应的坐标仍然为(2, 2)。我们发现6 > 2 * 2依然成立。于是我们可以得出，让循环继续的条件是“cols > startX * 2 && rows > startY * 2”。

      接下来我们分析如何按照顺时针的顺序打印一圈的数字。我们可以分四步来打印：第一步是从左到右打印一行，第二步是从上到下打印一列，第三步从右到左打印一行，最后一步是从下到上打印一列。也就是我们把打印一圈数字这个问题，分解成四个子问题。

      值得注意的是，最后一圈可能退化成只有一行、只有一列、甚至只有一个数字，因此打印这样的一圈就不需要四步了。

 


完整代码及测试用例：

#include<iostream>
using namespace std;

void PrintMatrixInCircle(int** numbers, int columns, int rows, int start);
void printNumber(int number);

//顺时针打印矩阵
void PrintMatrixClockwisely(int** numbers, int cols, int rows)
{
if (numbers == NULL || cols <= 0 || rows <= 0)
{
return;
}

int start = 0;

while (cols>start*2&&rows>start*2)
{
PrintMatrixInCircle(numbers, cols, rows, start);
start++;
}
}

//在圆圈中打印矩阵，打印一圈分4种情况:一步，二步，三步，四步
void PrintMatrixInCircle(int** numbers, int cols, int rows, int start)
{
int endX = cols - 1 - start;
int endY = rows - 1 - start;

// 从左到右打印一行
for (int i = start; i <= endX; i++)
{
int number = numbers[start][i];
printNumber(number);
}
//从上到下打印一列
if (start < endY)
{
for (int i = start + 1; i <= endY; i++)
{
int number = numbers[i][endX];
printNumber(number);
}
}
// 从右到左打印一行
if (start < endX&&start < endY)
{
for (int i = endX - 1; i >= start; i--)
{
int number = numbers[endY][i];
printNumber(number);
}
}
// 从下到上打印一行
if (start < endX&&start < endY - 1)
{
for (int i = endY - 1; i >= start+1; i--)
{
int number = numbers[i][start];
printNumber(number);
}
}

}

//打印数字
void printNumber(int number)
{
cout<<number<<"   ";
}

// ====================测试代码====================
void Test(int cols, int rows)
{
cout << "Test Begin:" << cols << " cols," << rows << " rows." << endl;

if (cols < 1 || rows < 1)
{
return;
}

int** numbers = new int*[rows];
for (int i = 0; i < rows; i++)
{
numbers[i] = new int[cols];
for (int j = 0; j < cols; j++)
{
numbers[i][j] = i * cols + j + 1;
}
}

PrintMatrixClockwisely(numbers, cols, rows);
cout << endl;

for (int i = 0; i < rows; ++i)
delete[](int*)numbers[i];

delete[] numbers;
}

int main()
{
/*
1
*/
Test(1, 1);

/*
1    2
3    4
*/
Test(2, 2);

/*
1     2    3    4
5     6    7    8
9    10   11    12
13   14   15    16
*/
Test(4, 4);

/*
1    2    3    4    5
6    7    8    9    10
11   12   13   14   15
16   17   18   19   20
21   22   23   24   25
*/
Test(5, 5);

/*
1
2
3
4
5
*/
Test(1, 5);

/*
1    2
3    4
5    6
7    8
9    10
*/
Test(2, 5);

/*
1    2    3
4    5    6
7    8    9
10   11   12
13   14   15
*/
Test(3, 5);

/*
1    2    3      4
5    6    7      8
9    10   11    12
13   14   15    16
17   18   19    20
*/
Test(4, 5);

/*
1    2    3    4    5
*/
Test(5, 1);

/*
1    2    3    4    5
6    7    8    9    10
*/
Test(5, 2);

/*
1    2    3    4      5
6    7    8    9     10
11   12   13   14    15
*/
Test(5, 3);

/*
1    2    3    4    5
6    7    8    9    10
11   12   13   14   15
16   17   18   19   20
*/
Test(5, 4);

system("pause");
return 0;
}

运行结果：

Test Begin:1 cols,1 rows.

1

Test Begin:2 cols,2 rows.

1   2   4   3

Test Begin:4 cols,4 rows.

1   2   3   4   8   12   16   15   14   13   9   5   6   7   11   10

Test Begin:5 cols,5 rows.

1   2   3   4   5   10   15   20   25   24   23   22   21   16   11   6   7   8   9   14   19   18   17   12   13

Test Begin:1 cols,5 rows.

1   2   3   4   5

Test Begin:2 cols,5 rows.

1   2   4   6   8   10   9   7   5   3

Test Begin:3 cols,5 rows.

1   2   3   6   9   12   15   14   13   10   7   4   5   8   11

Test Begin:4 cols,5 rows.

1   2   3   4   8   12   16   20   19   18   17   13   9   5   6   7   11   15   14   10

Test Begin:5 cols,1 rows.

1   2   3   4   5

Test Begin:5 cols,2 rows.

1   2   3   4   5   10   9   8   7   6

Test Begin:5 cols,3 rows.

1   2   3   4   5   10   15   14   13   12   11   6   7   8   9

Test Begin:5 cols,4 rows.

1   2   3   4   5   10   15   20   19   18   17   16   11   6   7   8   9   14   13   12

请按任意键继续. . .