class Solution {
    public:
            vector<int> spiralOrder(vector<vector<int> > &matrix) {
                    vector<int> ret;
                    int cols = 0;
                    int rows = 0;
                    if (!(rows = matrix.size()) || !(cols = matrix[0].size())) {
                            return ret;
                    }
                    int left = 0, top = 0, right = cols - 1, bottom = rows - 1;
                    while (left <= right && top <= bottom) {
                        circle_walk(left, top, right, bottom, matrix, ret);
                        left++, top++, bottom--, right--;
                    }
                    return ret;
            }

            void circle_walk(int left, int top, int right, int bottom, vector<vector<int> >& map, vector<int>& path) {
                    int rows = 0;
                    if (map.size() < 1 || map[0].size() < 1) return;
                            
                    // top row
                    for (int i=left; i<=right; i++) {
                        path.push_back(map[top][i]);
                    }

                    // right col
                    for (int i=top+1; i<=bottom; i++) {
                        path.push_back(map[i][right]);
                    }

                    // bottom row
                    for (int i=right-1; bottom != top && i>=left; i--) {
                        path.push_back(map[bottom][i]);
                    }

                    // left col
                    for (int i=bottom-1; left != right && i>top; i--) {
                        path.push_back(map[i][left]);
                    }

            }
};