【剑指】29.顺时针打印矩阵

题目描述

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

算法分析

 

• 矩阵的顺时针圈数取决于列和行较小的一个；
• 圈循环时存在边角点的从属问题，若边角点作为下一次循环中的第一个数，考虑到各种情况，代码处理会比较复杂，因此将边角点作为上一次循环中的最后一个数输出；
• 当矩阵为单行及单列时候，会出现重复输出的情况(从上到下后，又从下到上输出；从左到右后，又从右到左输出)，因此需要判断出该两种情况，以单行情况为例，加入(row-circle-1) != circle的判断，等式左边为循环某圈时，行的最大索引，等式右边为此圈行的初始索引，如两者相等，则必为单行情况，可以体会一下。

提交代码：

class Solution {
public:
	vector<int> printMatrix(vector<vector<int> > matrix) {
		if (matrix.empty() || matrix[0].empty())
			return vector<int>();
		
		int row = matrix.size();//行数
		int col = matrix[0].size();//列数
		int circles = ((row < col ? row : col) - 1) / 2 + 1;

		vector<int> result;
		for (int circle = 0; circle < circles; ++circle)
		{
			/* 从左到右 */
			for (int i = circle; i < col - circle; ++i)
				result.push_back(matrix[circle][i]);
			/* 从上到下 */
			for (int i = circle + 1; i < row - circle; ++i)
				result.push_back(matrix[i][col - circle - 1]);
			/* 从右到左 */
			// row - circle - 1 意为矩阵从后往前，倒数第circle行;
			// 若第circle行与倒数circle行相等，说明只有单行
			for (int i = col - circle - 2; (i >= circle) 
				&& (row - circle - 1 != circle); --i)
				result.push_back(matrix[row - circle -1][i]);
			/* 从下到上 */
			// col - circle - 1 意为矩阵从后往前，倒数第circle列;
			// 若第circle列与倒数circle列相等，说明只有单列
			for (int i = row - circle -2; (i > circle) 
				&& (col - circle - 1 != circle); --i)
				result.push_back(matrix[i][circle]);
		}
		return result;
	}
};

提交代码2：

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        if (matrix.empty() || matrix[0].empty()) return vector<int>();
        int m = matrix.size(), n = matrix[0].size();
        int start_x = 0, start_y = 0;
        int end_x = m - 1, end_y = n - 1;

        vector<int> ans;
        while (start_x * 2 < m && start_y * 2 < n) {
            // left -> right
            for (int j = start_y; j <= end_y; ++j) {
                ans.push_back(matrix[start_x][j]);
            }        
            // up -> down
            for (int i = start_x + 1; i <= end_x; ++i) {
                ans.push_back(matrix[i][end_y]);
            }
            // right -> left
            for (int j = end_y - 1; j >= start_y && start_x != end_x; --j) {
                ans.push_back(matrix[end_x][j]);
            }
            // down -> up
            for (int i = end_x - 1; i >= start_x + 1 && start_y != end_y; --i) {
                ans.push_back(matrix[i][start_y]);
            }             

            ++start_x, ++start_y;
            --end_x, --end_y;
        }
        return ans;
    }
};

测试代码：

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

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

	vector<vector<int> > numbers;
	for (int i = 0; i < rows; ++i)
	{
		vector<int> temp;
		for (int j = 0; j < columns; ++j)
		{
			temp.push_back(i * columns + j + 1);
		}
		numbers.push_back(temp);
	}
	Solution s;
	vector<int> result = s.printMatrix(numbers);

	for (int each : result)
		cout << each << " ";
	cout << endl;
}

int main(int argc, char* argv[])
{
	/*
	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);

	return 0;
}