Spiral Matrix

 Spiral Matrix

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

Example 1:

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

Example 2:

Input:
[
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9,10,11,12]
]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]

HERE IS C++ SOLUTION:

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
         
        int n=matrix.size()-1;
        if(n==-1)return {};
        int m=matrix[0].size()-1;
        vector<int> ans;
        int r=0,c=0;
        while(r<=n&&c<=m)
        {
            
            for(int i=c;i<=m;++i)
                ans.push_back(matrix[r][i]);
            ++r;
            
            for(int i=r;i<=n;++i)
                ans.push_back(matrix[i][m]);
            --m;
            
              if(c<=m&&r<=n)
              {
            for(int i=m;i>=c;--i)
                ans.push_back(matrix[n][i]);
                }        
            --n;
              
            if(r<=n&&c<=m)
                
            {for(int i=n;i>=r;--i)
                 ans.push_back(matrix[i][c]);}
            ++c;
        }
        return ans;
    }
};

HERE IS JAVA SOLUTION:

This is a very simple and easy to understand solution. I traverse
 right and increment rowBegin, then traverse down and decrement
  colEnd, then I traverse left and decrement rowEnd, and finally
   I traverse up and increment colBegin.

The only tricky part is that when I traverse left or up I have
 to check whether the row or col still exists to prevent 
 duplicates. If anyone can do the same thing without that
  check, please let me know!

Any comments greatly appreciated.

public class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        
        List<Integer> res = new ArrayList<Integer>();
        
        if (matrix.length == 0) {
            return res;
        }
        
        int rowBegin = 0;
        int rowEnd = matrix.length-1;
        int colBegin = 0;
        int colEnd = matrix[0].length - 1;
        
        while (rowBegin <= rowEnd && colBegin <= colEnd) {
            // Traverse Right
            for (int j = colBegin; j <= colEnd; j ++) {
                res.add(matrix[rowBegin][j]);
            }
            rowBegin++;
            
            // Traverse Down
            for (int j = rowBegin; j <= rowEnd; j ++) {
                res.add(matrix[j][colEnd]);
            }
            colEnd--;
            
            if (rowBegin <= rowEnd) {
                // Traverse Left
                for (int j = colEnd; j >= colBegin; j --) {
                    res.add(matrix[rowEnd][j]);
                }
            }
            rowEnd--;
            
            if (colBegin <= colEnd) {
                // Traver Up
                for (int j = rowEnd; j >= rowBegin; j --) {
                    res.add(matrix[j][colBegin]);
                }
            }
            colBegin ++;
        }
        
        return res;
    }
}

HERE IS PAYTHON SOLUTION:

The con is mutating the matrix, if this is not allowed,
 we can make a deep copy of the matrix first.
  And of course it comes with the additional memory usage.

def spiralOrder(self, matrix):
    ret = []
    while matrix:
        ret += matrix.pop(0)
        if matrix and matrix[0]:
            for row in matrix:
                ret.append(row.pop())
        if matrix:
            ret += matrix.pop()[::-1]
        if matrix and matrix[0]:
            for row in matrix[::-1]:
                ret.append(row.pop(0))
    return ret