剑指offer【面试题20：顺时针打印矩阵】

题目描述

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

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.

 

 

思路：

1、对任意一个矩阵，获取其外围边界，按题目要求顺序放进数组（顺序顶部、右边、底部、左边）；

2、缩小给定矩阵（剥离外围边界）

重复步骤1、2即可。

注意:注意当矩阵为行或者列向量的时候，遍历可能会存在越界问题，你可以作特殊处理

//输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，
//例如，如果输入如下4 X 4矩阵： 
/*
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.
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
// 打印vector<int>
void myprintfVec(vector<int>& vec)
{
    if (vec.empty())
    {
        cout << "empty !" << endl;
        return;
    }
    else
    {
        for (auto& ele:vec)
        {
            cout << ele << " ";
        }
        cout << endl;
    }
}
// 打印vector<vector<int>>
void myprintfVecs(vector<vector<int>> vecs)
{
    if (vecs.empty())
    {
        cout << "vector<vector<int>> empty!" << endl;
    }
    else
    {
        int rows = vecs.size();
        int cols = vecs[0].size();
        for (int j = 0; j < rows; j++)
        {
            for (int i = 0; i < cols; i++)
            {
                cout.width(3);
                cout << vecs[j][i] << " ";
            }
            cout << endl;
        }
    }
    
}
// 获取一个矩阵的边界
vector<int> getTheBorder(const vector<vector<int>> matrix)
{
    vector<int> top, bottom, left, right;
    const int rows = matrix.size();
    const int cols = matrix[0].size();
    vector<int> result;
    //顺时针
    if ((rows == 1) || (cols == 1)) // 当给定矩阵是行、列向量的时候
    {
        for (int j = 0; j < rows; j++)
        {
            for (int i = 0; i < cols; i++)
            {
                result.push_back(matrix[j][i]);
            }
        }
    }
    else
    {
        // 顶部
        for (int i = 0; i < cols; i++)
        {
            result.push_back(matrix[0][i]);
        }
        //myprintfVec(top);
        //右列
        for (int j = 1; j < (rows - 1); j++)
        {
            result.push_back(matrix[j][cols - 1]);
        }
        //myprintfVec(right);
        //底部
        for (int m = cols - 1; m >= 0; m--)
        {
            result.push_back(matrix[rows - 1][m]);
        }
        //myprintfVec(bottom);
        //左列
        for (int n = (rows - 2); n > 0; n--)
        {
            result.push_back(matrix[n][0]);
        }
        //myprintfVec(left);
    }
    //myprintfVec(result);
    return result;
}
// 
void printMatrix(vector<vector<int> >& matrix) 
{
    const int rows = matrix.size();
    const int cols = matrix.at(0).size();
    // 比如 4x5的矩阵，你要剥离 2圈； 7x8的矩阵，你要剥离 4圈
    int totalsteps = round(min(rows, cols)/2.0); //剥离圈数
    vector<int> array_;
    for (int step = 0; step < totalsteps; step++)// 一共剥离 totalsteps 圈
    {
        vector<vector<int>> matrix_;
        vector<int> temp;
        // 构建的矩阵matrix_ 初始化
        for (int i = 0; i < cols - 2*step; i++)
            temp.push_back(0);
        for (int j = 0; j < rows - 2*step; j++)
            matrix_.push_back(temp);
        //myprintfVecs(matrix_);
        // 剥离后的矩阵matrix_
        for ( int j = 0; j < rows - 2 * step; j++)
        {
            for (int i = 0; i < cols - 2 * step; i++)
            {
                matrix_[j][i] = matrix[j+step][i+step];
            }
        }
        // 获取边界
        vector<int> border = getTheBorder(matrix_);
        myprintfVec(border);
    }
}

void dosomeboring(vector<int>& vec,const int add)
{
    for (size_t i = 0; i < vec.size(); i++)
    {
        vec[i] += add;
    }
}

int main()
{
    const int rows = 15;
    const int cols = 5;
    vector<vector<int>> vecs;
    // 创建一个矩阵
    for (size_t i = 0; i < rows; i++)
    {
        vector<int> vec;
        for (size_t i = 0; i < cols; i++)
            vec.push_back(i);

        dosomeboring(vec, i);
        vecs.push_back(vec);
    }
    // 打印上述创建的矩阵
    myprintfVecs(vecs);

    // 按照题目傻逼要求打印
    printMatrix(vecs);
    return 1;
}