《剑指Offer》面试题20：顺时针打印矩阵

《剑指Offer》面试题20：顺时针打印矩阵

知识点

    数组

题目描述

    输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。例如：如果输入如下矩阵：

    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。

    当遇到一个复杂的问题的时候，我们可以用图形来帮助我们来思考。由于是从外圈到内圈的顺序依次打印，我们可以把矩阵想象成若干个圈，如图所示。我们可以用一个循环来打印矩阵，每一次打印矩阵中的一个圈。

    接下来分析循环结束的条件。假设这个矩阵的行数是rows，列数是columns。打印第一个圈是左上角元素的坐标是（0，0），第二圈的左上角的坐标是（1，1），以此类推。我们注意到，左上角的坐标中行标和列标总是相同的，于是可疑在矩阵中选取左上角为（start，start）的一圈为我们分析的目标。

    对一个5*5的矩阵而言，最后一圈只有一个数字，对应的坐标为（2，2）。我们发现5>2*2.对于一个6*6的矩阵而言，最后一圈有4个数字，其左上角的坐标仍然为（2，2）。我们发现6>2*2依然成立。于是我们可以得出继续循环的条件是columns>startX*2并且rows>startY*2.

    接着我们考虑如何打印一圈的功能，即如何实现PrintMatrixInCircle。如图所示，我们可以把打印一圈分为四步：第一步从做到右打印一行，第二步从上到下打印一行，第三步从右到左打印一行，第四步从下到上打印一列。每一步我们根据起始坐标用一个循环就能打印出一行或者一列。

    不过值得注意的是，最后一圈有可能退化成只有一行、只有一列，甚至只有一个数字，因此打印这样的一圈就不再需要四步。图是几个退化的例子，打印一圈分别只需要三步、两步甚至只有一步。

    因此我们要仔细分析打印时的每一步的前提条件。第一步总是需要的，因为打印一圈至少需要一步。如果只有一行，那么就不用第二步了。也就是需要第二步的前提条件是终止号大于起止号。需要第三步打印的前提条件是圈内至少有两行两列，也就是说除了要求终止行号大于起始行号之外，还要求终止列号大于起始列号。同理，需要打印第四步的前提条件是至少有三行两列，因此要求终止行号比其实行号至少大2，同时终止列号大于起始列号。

测试用例

代码（原书）

/*《剑指Offer——名企面试官精讲典型编程题》代码
著作权所有者：何海涛*/

#include "stdio.h"
#include "cstdlib"

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

void PrintMatrixClockwisely(int** numbers, int columns, int rows)
{
	if (numbers == NULL || columns <= 0 || rows <= 0)
		return;

	int start = 0;

	while (columns > start * 2 && rows > start * 2)
	{
		PrintMatrixInCircle(numbers, columns, rows, start);

		++start;
	}
}

void PrintMatrixInCircle(int** numbers, int columns, int rows, int start)
{
	int endX = columns - 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)
{
	printf("%d\t", number);
}

// ====================测试代码====================
void Test(int columns, int rows)
{
	printf("Test Begin: %d columns, %d rows.\n", columns, rows);

	if (columns < 1 || rows < 1)
		return;

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

	PrintMatrixClockwisely(numbers, columns, rows);
	printf("\n");

	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;
}

代码（牛客网）

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) 
    
    {

        int rows = matrix.size();
        int cols = matrix[0].size();
       
        vector<int> result;
        result.clear();
        if(rows==0||cols==0)
            return result;
        int start = 0;
        while(start * 2 < rows && start * 2 < cols)
        {
            PrintMatirxInCircle(matrix, rows, cols, start, result);
            ++ start;
        }
        return result;

    }
private:
        void PrintMatirxInCircle(vector<vector<int>> matrix, int rows, int cols, int start, vector<int> &result)
        {
            int endX = rows - 1 - start;
            int endY = cols - 1 - start;
           
            for(int i = start; i <= endY; i++)           //从左向右打印
             {
                 
                 result.push_back(matrix[start][i]);
             }
            
            if(endX > start)                             //从上向下打印
            {
                for(int i = start+1; i <= endX; i++)
                {
                    
                    result.push_back(matrix[i][endY]);
                }
            }
            if(endY > start && endX > start)              //从右向左打印
            {
                for(int i = endY-1; i>=start; i--)
                {
                    
                    result.push_back(matrix[endX][i]);
                }
            } 
            if(endY > start && endX-1 > start)           //从下向上打印
            {
                for(int i = endX - 1; i >= start + 1; i--)
                {
                    
                    result.push_back(matrix[i][start]);
                }
            }
        }
};