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

共以下 4 个回答

• shuaidi 永久会员 2025年4月21日 上午1:20

  测试

  0 赞同 0 条回复

  登录以回复
• 陆狗陆狗 普通 2025年1月8日 上午10:54

  解题思路
  – 按照上右下左的顺序进行遍历，注意4个边界的缩减
  【题解1】

  class Solution {
      public int[] spiralArray(int[][] array) {
          // 【错误】边界判断
          if(array.length==0){
              return new int[0];
          }
  
          // 思路：正常进行遍历即可，关键是缩减遍历的边界
          int up = 0;
          int down = array.length - 1;
          int left = 0;
          int right = array[0].length - 1;
          int[] result = new int[array.length * array[0].length];
          int cur = 0;
          // 【错误】注意应该是<=,因为array只有一行，up=down=0；只有一列，left=right=0，最终结束的条件就是up和down错位 或者 left和right错位
          while (up <= down && left <= right) {
              // 遍历上边
              for (int j = left; j <= right; j++) {
                  result[cur] = array[up][j];
                  cur++;
              }
              up++;
              // 遍历右边
              for (int i = up; i <= down; i++) {
                  result[cur] = array[i][right];
                  cur++;
              }
              right--;
  
              // 遍历下边
              if (up <= down) {
                  for (int j = right; j >= left; j--) {
                      result[cur] = array[down][j];
                      cur++;
                  }
                  down--;
              }
  
              // 遍历左边
              if (left <= right) {
                  for (int i = down; i >= up; i--) {
                      result[cur] = array[i][left];
                      cur++;
                  }
                  left++;
              }
          }
          return result;
      }
  }
  

  • 错误点1：边界判断
  • 错误点2：注意应该是<=,因为array只有一行，up=down=0；只有一列，left=right=0，最终结束的条件就是up和down错位 或者 left和right错位

  0 赞同 0 条回复

  登录以回复
• Aatorx 永久会员 2024年12月30日 下午3:52

  class Solution {
  public:
      vector<int> spiralArray(vector<vector<int>>& array) {
          vector<int> res;
          if(array.empty()) {
              return res;
          }
          int b = array.size() - 1;
          int r = array[0].size() - 1;
          int l = 0;
          int t = 0;
          while(true) {
              for(int j = l; j <= r; j++) {
                  res.push_back(array[t][j]);
              }
              t++;
              if(t > b) break;
              for(int i = t; i <= b; i++) {
                  res.push_back(array[i][r]);
              }
              r--;
              if(r < l) break;
              for(int j = r; j >= l; j--) {
                  res.push_back(array[b][j]);
              }
              b--;
              if(b < t) break;
              for(int i = b; i >= t; i--) {
                  res.push_back(array[i][l]);
              }
              l++;
              if(l > r) break;
          }
          return res;
      }
  };
  

  时间复杂度O(Mn)，空间复杂度O(Mn)。

  0 赞同 0 条回复

  登录以回复
• 晓宇 普通 2024年12月29日 下午12:43

  // 螺旋遍历
  class Solution {
  public:
      vector<int> spiralArray(vector<vector<int>>& array) {
          if(array.empty() || array[0].empty()) return vector<int>();
          vector<int> ans;
          int lef = 0,rit = array[0].size() - 1,bot = array.size() - 1,top = 0;
          while(true){
              for(int i = top,j = lef;j <= rit;j++){
                  ans.push_back(array[i][j]);
              }
              top += 1; // 下移一层
              if(top > bot) break;
              for(int i = top,j = rit;i <= bot;i++){
                  ans.push_back(array[i][j]);
              }
              rit -= 1; // 左移一层
              if(rit < lef) break;
              for(int i = bot,j = rit;j >= lef;j--){
                  ans.push_back(array[i][j]);
              }
              bot -= 1; // 上移一层
              if(bot < top) break;
              for(int i = bot,j = lef;i >= top ;i--){
                  ans.push_back(array[i][j]);
              }
              if(++lef > rit) break;// 右移一层
          }
          return ans;
      }
      // o(n^2) o(1)
  };
  

  0 赞同 0 条回复

  登录以回复