标签：返回   递归   res   int   使用   +=   push   top   first   

剑指OFFER 顺时针打印矩阵

试错

没想到这道题竟然花了这么长时间

先是用了递归,结果超时了

递归解

class Solution {
public:
    vector<int> res;
    void printSuround(vector<vector<int>> &m,int x,int y)
    {
        int size = m.size();
        if(m[x][y]==-1)return;
        while(x>=0 && y>=0 && x<size && y<size && m[x][y]!=-1)
        {
            res.push_back(m[x][y]);
            m[x][y]=-1;
            y++;
        }
        y--;
        x++;
        while(x>=0 && y>=0 && x<size && y<size && m[x][y]!=-1)
        {
            res.push_back(m[x][y]);
            m[x][y]=-1;
            x++;
        }
        x--;
        y--;
        while(x>=0 && y>=0 && x<size && y<size && m[x][y]!=-1)
        {
            res.push_back(m[x][y]);
            m[x][y]=-1;
            y--;
        }
        y++;
        x--;
        while(x>=0 && y>=0 && x<size && y<size && m[x][y]!=-1)
        {
            res.push_back(m[x][y]);
            m[x][y]=-1;
            x--;
        }
        x++;
        y++;
        printSuround(m,x,y);
    }

    vector<int> printMatrix(vector<vector<int>> matrix) {
        res.clear();
        if(matrix.size() == 0)return res;//如果矩阵空则返回一个空vector
        printSuround(matrix,0,0);
        return res;
    }
};

循环解

不使用递归,转换为循环,仍超时... 懵了

class Solution {
public:
    vector<int> res;
    pair<int,int> fac[4] = {{0,1},{1,0},{0,-1},{-1,0}};

    vector<int> printMatrix(vector<vector<int>> m) {
        res.clear();
        if(m.size() == 0)return res;//如果矩阵空则返回一个空vector
        if(m.size() == 1)
        {
            res.push_back(m[0][0]);
            return res;
        }
        int x = 0;
        int y = 0;
        int size = m.size();
        while(m[x][y] != -1)
        {
            for(int i=0;i<4;i++)
            {
                while(x>=0 && y>=0 && x<size && y<size && m[x][y] != -1)
                {
                    res.push_back(m[x][y]);
                    m[x][y] = -1;
                    x += fac[i].first;
                    y += fac[i].second;
                }
                x -= fac[i].first;
                y -= fac[i].second;
                x += fac[(i+1)%4].first;
                y += fac[(i+1)%4].second;
            }
        }
        return res;
    }
};

现在还没弄明白是哪个步骤这么耗时,复杂度应该是差不多,先放这,以后弄明了再补充

题解

实在顶不住了,屈辱地抄下大神的代码

class Solution {
public:
    vector<int> printMatrix(vector<vector<int>> matrix) {
        int row=matrix.size();
        int col=matrix[0].size();
        vector<int> result;
        if(row==0||col==0)
            return result;
        int left=0,right=col-1,top=0,btm=row-1;
        while(left<=right&&top<=btm)
            {
            for(int i=left;i<=right;i++)
                result.push_back(matrix[top][i]);
            if(top<btm)
                for(int i=top+1;i<=btm;i++)
                    result.push_back(matrix[i][right]);
            if(top<btm&&left<right)
                for(int i=right-1;i>=left;i--)
                    result.push_back(matrix[btm][i]);
            if(top+1<btm&&left<right)
                for(int i=btm-1;i>=top+1;i--)
                    result.push_back(matrix[i][left]);
            left++;right--;top++;btm--;
        }
        return result;
    }
};

剑指OFFER 顺时针打印矩阵

标签：返回   递归   res   int   使用   +=   push   top   first   

原文地址：https://www.cnblogs.com/virgildevil/p/12188733.html