Spiral Matrix [Leetcode]

Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.
For example,
Given the following matrix:

[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]

You should return [1,2,3,6,9,8,7,4,5].

Solutions:  print the matrix layer by layer from outside to inside; we can do this both recursively and iteratively.

   /*******************************SOLUTION 1***********************************/

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int> > &matrix) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        vector<int> ret;
        
        //basic cases
        int m = matrix.size();
        if(m==0) return ret;
        if(m==1) return matrix[0];

        int n = matrix[0].size();
        if(n==0) return ret;
        if(n==1){
            for(int i=0; i<m; i++)
                ret.push_back(matrix[i].front());
            return ret;
        }
        
        ret.reserve(2*(n+m)-4);

        //copy and remove the out-most layer
        ret.insert(ret.end(), matrix.front().begin(), matrix.front().end());
        matrix.erase(matrix.begin());
        
        for(int i=0; i<m-2; i++){
            ret.push_back(matrix[i].back());
            matrix[i].pop_back();
        }

        reverse(matrix.back().begin(), matrix.back().end());
        ret.insert(ret.end(), matrix.back().begin(), matrix.back().end());
        matrix.pop_back();
        
        for(int i=0; i<m-2; i++){
            ret.push_back(matrix[m-3-i].front());
            matrix[m-3-i].erase(matrix[m-3-i].begin());
        }

        //solve the remaining sub-matrix
        vector<int> subRet;
        subRet = spiralOrder(matrix);
        //combine
        ret.insert(ret.end(), subRet.begin(), subRet.end());
        return ret;
    }
};

   /*******************************SOLUTION 2***********************************/

 
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int> > &matrix) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        vector<int> ret;
        if(matrix.empty()) return ret;
        if(matrix[0].empty()) return ret;
        
        int row = 0, col = 0, numRow = matrix.size(), numCol = matrix[0].size();
        ret.reserve(numRow*numCol);

        while(numRow>0 && numCol>0){
            if(numRow==1){
                for(int i=0; i<numCol; i++)
                    ret.push_back(matrix[row][col+i]);
                break;
            }
            else if(numCol==1){
                for(int i=0; i<numRow; i++)
                    ret.push_back(matrix[row+i][col]);
                break;
            }
            for(int i=0; i<numCol; i++)
                ret.push_back(matrix[row][col+i]);
            for(int i=1; i<numRow-1; i++)
                ret.push_back(matrix[row+i][col+numCol-1]);
            for(int i=0; i<numCol; i++)
                ret.push_back(matrix[row+numRow-1][col+numCol-1-i]);
            for(int i=1; i<numRow-1; i++)
                ret.push_back(matrix[row+numRow-1-i][row]);
            ++row; ++col;
            numRow-=2; numCol-=2;
        }
        return ret;
    }
};