C++剑指offer——顺时针打印矩阵

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.

解法

解法一：暴力法
我做得比较复杂，设了一个标志数组visit，从头遍历，碰到没有被访问过的点就以他为开始，开始顺时针走一遍。这里面有四条边，所以涉及四个循环。循环的结束条件当然是越界或者碰到已经被访问过的。
时间复杂度：O（N²）
空间复杂度：O（N）
代码：

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) 
    {
        vector<int> s;
        int height=matrix.size();
        int width=matrix[0].size();
        bool visit[height][width];
        for(int i=0;i<height;i++)
            for(int j=0;j<width;j++)
                visit[i][j]=false;
        //
        for(int i=0;i<height;i++)
        {
            for(int j=0;j<width;j++)
            {
                if(visit[i][j]==false)
                {
                    int m1,m2,m3,m4;、
                    //上边
                    for(m1=j;m1<width;m1++)
                    {
                        if(visit[i][m1]==true)
                            break;
                        s.push_back(matrix[i][m1]);
                        visit[i][m1]=true;
                    }
                    //右边
                    for(m2=i+1;m2<height;m2++)
                    {
                        if(visit[m2][m1-1]==true)
                            break;
                        s.push_back(matrix[m2][m1-1]);
                        visit[m2][m1-1]=true;
                    }
                    //下边
                    for(m3=m1-2;m3>=0;m3--)
                    {
                        if(visit[m2-1][m3]==true)
                            break;
                        s.push_back(matrix[m2-1][m3]);
                        visit[m2-1][m3]=true;
                    }
                    //左边
                    for(m4=m2-2;m4>j;m4--)
                    {
                        if(visit[m4][m3+1]==true)
                            break;
                        s.push_back(matrix[m4][m3+1]);
                        visit[m4][m3+1]=true;
                    }
                }
            }
        }
        return s;
    }
};

解法二
看了别人的思路才知道用四个标志位置就可以进行解决（代码中的low、high、left、right代表了即将访问的上下左右四条线），把原来麻烦的问题简单化了。
时间复杂度：O（N）
空间复杂度：O（1）
代码：

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) 
    {
        vector<int> s;
        int low=0;
        int high=matrix.size()-1;
        int left=0;
        int right=matrix[0].size()-1;
        while(low<=high&&left<=right)
        {
            //向右
            for(int i=left;i<=right;i++)
                s.push_back(matrix[low][i]);
            //向下
            for(int i=low+1;i<=high;i++)
                s.push_back(matrix[i][right]);
            //向左，防止只有一行
            if(low<high)
                for(int i=right-1;i>=left;i--)
                    s.push_back(matrix[high][i]);
            //向上，防止只有一列
            if(left<right)
                for(int i=high-1;i>low;i--)
                    s.push_back(matrix[i][left]);
            high--;
            low++;
            left++;
            right--;
        }
        return s;
    }
};