【杂题】剑指 Offer 29. 顺时针打印矩阵-跟着帅地玩副业，开拓第二曲线PlayOffer

宁永久会员 2023年3月20日上午10:46

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0) return new int[0];
        //标记上下左右四个方向。遍历完某一边界则开始移动边界
        int l = 0, r = matrix[0].length - 1, t = 0, b = matrix.length - 1;
        int[] res = new int[(r + 1) * (b + 1)];
        int k = 0;
        while(true){
            for(int i = l; i <= r; i++){
                res[k++] = matrix[t][i];
            }
            if(++t > b) break;
            for(int i = t; i <= b; i++){
                res[k++] = matrix[i][r];
            }
            if(--r < l) break;
            for(int i = r; i >= l; i--){
                res[k++] = matrix[b][i];
            }
            if(--b < t) break;
            for(int i = b; i >= t; i--){
                res[k++] = matrix[i][l];
            }
            if(++l > r) break;
        }
        return res;
    }
}

0 赞同 0 条回复

lucca 普通 2023年1月18日上午12:05

恶心题，考验基本功

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if (matrix.length == 0 || matrix[0].length == 0)
            return new int[0];

        int n = matrix.length, m = matrix[0].length;
        int[] ans = new int[n * m];
        boolean[][] vis = new boolean[n][m];

        int x = 0, y = 0;
        ans[0] = matrix[0][0];
        vis[x][y] = true;

        int[] dx = {0, 1, 0, -1};
        int[] dy = {1, 0, -1, 0};
        int d = 0;

        for (int i = 1; i < n * m; i++) {
            int nx = x + dx[d], ny = y + dy[d];
            while (!(nx >= 0 && nx < n && 
                     ny >= 0 && ny < m && !vis[nx][ny])) {
                d = (d + 1) % 4;
                nx = x + dx[d]; ny = y + dy[d];
            }
            x = nx; y = ny;
            vis[x][y] = true;
            ans[i] = matrix[x][y];
        }
        return ans;
    }
}

0 赞同 0 条回复

y 普通 2022年12月3日下午3:46

var spiralOrder = function(matrix) {
  if (matrix.length === 0) {
      return [];
  }

  let left = 0;
  let right = matrix[0].length - 1;
  let up = 0;
  let down = matrix.length - 1;

  let res = [];

  while (left <= right && up <= down) {
    //   从左到右
      for (let i = left; i <= right; i++) {
          res.push(matrix[up][i]);
      }
      up = up + 1;
      if (up > down) break;
    // 从上到下
      for (let j = up; j <= down; j++) {
          res.push(matrix[j][right]);
      }
     right = right - 1;
    if (left > right) break;

    //  从右到左
    for (let z = right; z >= left; z--) {
        res.push(matrix[down][z])
    }

    down = down - 1;
// 从下到上
    for (let d = down; d >= up; d--) {
        res.push(matrix[d][left])
    }
   left = left + 1
  }
return res;

};

0 赞同 0 条回复

T 普通 2022年12月3日上午10:06

下面代码

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix.length == 0) return new int[0];
        int top = 0;
        int bottom = matrix.length - 1;
        int left = 0;
        int right = matrix[0].length - 1;
        int[] nums = new int[(right + 1) * (bottom + 1)];
        int count = 0;

        while(true) {
            for(int i = left; i <= right; i++) {
                nums[count++] = matrix[top][i];
            }
            if(++top > bottom) break;

            for(int i = top; i <= bottom; i++) {
                nums[count++] = matrix[i][right];
            }
            if(left > --right) break;

            for(int i = right; i >= left; i--) {
                nums[count++] = matrix[bottom][i];
            }
            if(top > --bottom) break;

            for(int i = bottom; i >= top; i--) {
                nums[count++] = matrix[i][left];
            }
            if(++left > right) break;
        }
        return nums;
    }
}

0 赞同 0 条回复

青木普通 2022年12月2日下午10:48

/**
    没想到可以直接在每一次打印的时候都判断一下边界是否溢出，题解写的太简洁了T_T

    时间O(m*n)
    空间O(1)
 */

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix.length==0) return new int[0];
        int l=0, r=matrix[0].length - 1, t=0, b=matrix.length - 1, x=0;
        int[] ans = new int[(r+1)*(b+1)];
        while(true){
            for(int i=l; i<=r; i++) ans[x++] = matrix[t][i];
            if(++t > b) break;
            for(int i=t; i<=b; i++) ans[x++] = matrix[i][r];
            if(l > --r) break;
            for(int i=r; i>=l; i--) ans[x++] = matrix[b][i];
            if(t > --b) break;
            for(int i=b; i>=t; i--) ans[x++] = matrix[i][l];
            if(++l > r) break;
        }
        return ans;
    }
}

0 赞同 0 条回复

訁訁訁訁訁普通 2022年12月1日上午11:29

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

时间复杂度O(NM)空间复杂度O(NM)

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if (matrix == null || matrix.length == 0) return new int[0];
        int m = matrix.length,n = matrix[0].length;
        int upper_bound = 0,lower_bound = m - 1;
        int left_bound = 0,right_bound = n - 1;
        int num = 1;
        int[] ret = new int[m*n];
        while(num <= m * n) {
            if (upper_bound <= lower_bound){
                for(int i = left_bound;i <= right_bound;i++) {
                ret[num-1] = matrix[upper_bound][i];
                num++;
            }
            }
            upper_bound++;
           if (left_bound <= right_bound) {
                for(int i = upper_bound;i <= lower_bound;i++) {
                ret[num-1] = matrix[i][right_bound];
                num++;
            }
           }
            right_bound--;
            if(upper_bound <= lower_bound) {
                for(int i = right_bound;i >= left_bound;i--) {
                ret[num-1] = matrix[lower_bound][i];
                num++;
            }
            }
            lower_bound--;
            if(left_bound <= right_bound) {
                for(int i = lower_bound;i >= upper_bound;i--) {
                ret[num-1] = matrix[i][left_bound];
                num++;
            }
            }
            left_bound++;
        }
        return ret;
    }
}

0 赞同 0 条回复

Mooby 普通 2022年12月1日上午9:50

// 时间复杂度：O(mn)，空间复杂度：O(1)
class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix.length == 0 || matrix[0].length == 0) {
            return new int[0];
        }
        int l = 0, r = matrix[0].length - 1, u = 0, d = matrix.length - 1;
        int[] res = new int[(r + 1) * (d + 1)];
        int k = 0;
        while(true){
            for(int i = u,j = l; j <= r; j++){
                res[k++] = matrix[i][j];
            }
            if(++u > d) {
                break;
            }
            for(int i = u, j = r; i <= d; i++) {
                res[k++] = matrix[i][j];
            }
            if(l > --r) {
                break;
            }
            for(int i = d, j = r; j >= l; j--) {
                res[k++] = matrix[i][j];
            }
            if(u > --d) {
                break;
            }
            for(int i = d, j = l; i >= u; i--) {
                res[k++] = matrix[i][j];
            }
            if(++l > r) {
                break;
            }
        }
        return res;
    }
}

0 赞同 0 条回复

西西弗斯的石头永久会员 2022年11月30日下午10:28

时间复杂度O（m*n）,空间复杂度O（1）

class Solution {
    public int[] spiralOrder(int[][] matrix) {
         if(matrix == null || matrix.length == 0 || matrix[0].length == 0){
            return new int[0];
        }
        int l = 0, r = matrix[0].length - 1, t = 0, b = matrix.length - 1;
        int[] res = new int[(r+1) * (b+1)];
        int k = 0;
        while(true){
            for(int i = t,j = l; j <= r; j++){
                res[k++] = matrix[i][j];
            }
            if(++t > b) break;
            for(int i = t, j = r; i <= b; i++){
                res[k++] = matrix[i][j];
            }
            if(--r < l) break;
            for(int i = b, j = r; j >= l;j--){
                res[k++] = matrix[i][j];
            }
            if(--b < t) break;
            for(int i = b, j = l;i >= t;i--){
                res[k++] = matrix[i][j];
            }
            if(++l > r) break;
        } 
        return res;

    }
}

0 赞同 0 条回复

🚲南下普通 2022年11月30日下午8:40

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.size() == 0 || matrix[0].size() == 0) 
            return {};
        vector<int> res;
        int top = 0;                      //上边界
        int bottom = matrix.size() - 1;   //下边界
        int left = 0;                     //左边界
        int right = matrix[0].size() - 1; //右边界

        while (true) {
            // 从左到右
            for (int i = left; i <= right; ++ i) 
                res.push_back(matrix[top][i]);
            // 每次从左往右执行一次，则要往下移一层
            if (++ top > bottom) break;
            // 从上到下
            for (int i = top; i <= bottom; ++ i) 
                res.push_back(matrix[i][right]);
            // 每次从上到下执行一次，则要往左移一列
            if (-- right < left) break;
            // 从右到左
            for (int i = right; i >= left; -- i) 
                res.push_back(matrix[bottom][i]);
            // 每次从右到左执行一次，则要往上移一行
            if (-- bottom < top) break;
            // 从下到上
            for (int i = bottom; i >= top; -- i) 
                res.push_back(matrix[i][left]);
            // 每次从下到上执行一次，则要往右移一列
            if (++ left > right) break;
        }
        return res;
    }
};

0 赞同 0 条回复

【杂题】剑指 Offer 29. 顺时针打印矩阵

共以下 9 个回答

恶心题，考验基本功

# 回答此问题取消回复

【杂题】剑指 Offer 29. 顺时针打印矩阵

共以下 9 个回答

恶心题，考验基本功

# 回答此问题 取消回复

# 回答此问题取消回复