精华内容
下载资源
问答
  • 二维数组顺时针遍历

    2020-08-16 13:11:49
    二维数组顺时针遍历 1、题目要求 From PDD 给你一个 m*n 的二维数组 arr[][],按照顺时针遍历输出 比如下面的数组,其输出顺序应该为 1~15 int[][] arr = new int[][]{ {1, 2, 3, 4, 5}, {12, 13, 14, 15, 6...

    二维数组顺时针遍历

    1、题目要求

    From PDD

    1. 给你一个 m*n 的二维数组 arr[][],按照顺时针遍历输出

    2. 比如下面的数组,其输出顺序应该为 1~15

      int[][] arr = new int[][]{
          {1, 2, 3, 4, 5},
          {12, 13, 14, 15, 6},
          {11, 10, 9, 8, 7},
      };
      

    2、代码思路

    这道题并不难,使用两个变量 row 和 col 分别作为行、列指针,使用两个变量 xLeft 和 xRight 维护左右边界,使用两个变量 yUp 和 yDown 维护上下边界,使用一个变量 direction 维护当前遍历的方向

    3、代码实现

    1. 代码

      /**
       * @ClassName ArrayClockwiseIter
       * @Description TODO
       * @Author Heygo
       * @Date 2020/8/16 12:43
       * @Version 1.0
       */
      public class ArrayClockwiseIter {
      
          public static void main(String[] args) {
              int[][] arr = new int[][]{
                      {1, 2, 3, 4, 5},
                      {12, 13, 14, 15, 6},
                      {11, 10, 9, 8, 7},
              };
              clockwiseIter(arr);
          }
      
          /**
           * 顺时针遍历输出二维数组
           * @param arr 待遍历输出的二维数组
           */
          public static void clockwiseIter(int[][] arr) {
      
              // 行、列指针
              int row = 0;
              int col = 0;
      
              // 列的左右边界
              int xLeft = 0;
              int xRight = arr[0].length - 1;
      
              // 行的上下边界
              int yUp = 0;
              int yDown = arr.length - 1;
      
              // 已遍历输出的元素个数
              int count = 0;
              int totalCount = arr.length * arr[0].length;
      
              // 行走方向:0 表示从左往右,1 表示从上往下,2 表示从右往左,3 表示从下往下
              int direction = 0;
      
              while (count < totalCount) {
                  if (direction == 0) {
                      for (col = xLeft; col <= xRight; col++, count++) {
                          System.out.print(arr[row][col]+" ");
                      }
                      System.out.println();
                      yUp += 1; // 上边界
                      direction = 1; // 变换方向
                      col--;
                  } else if (direction == 1) {
                      for (row = yUp; row <= yDown; row++, count++) {
                          System.out.print(arr[row][col]+" ");
                      }
                      System.out.println();
                      xRight -= 1; // 右边界
                      direction = 2; // 变换方向
                      row--;
                  } else if (direction == 2) {
                      for (col = xRight; col >= xLeft; col--, count++) {
                          System.out.print(arr[row][col]+" ");
                      }
                      System.out.println();
                      yDown -= 1; // 下边界
                      direction = 3; // 变换方向
                      col++;
                  } else if (direction == 3) {
                      for (row = yDown; row >= yUp; row--, count++) {
                          System.out.print(arr[row][col]+" ");
                      }
                      System.out.println();
                      xLeft += 1; // 左边界
                      direction = 0; // 变换方向
                      row++;
                  }
              }
      
          }
      
      }
      
    2. 程序运行结果

      1 2 3 4 5 
      6 7 
      8 9 10 11 
      12 
      13 14 15 
      
    展开全文
  • 顺时针遍历矩阵

    2020-10-01 21:03:42
    顺时针遍历二维数组。 忘了是在哪看到的这个问题,刚看到时直接懵逼了。不过其实还好吧 闲着没事干就把他给写了出来。 我们定义 上面边界 up , 下面边界down, 左边边界left, 右边边界rihgt; 然后分别 按照次序进行...

    顺时针遍历二维数组。

    忘了是在哪看到的这个问题,刚看到时直接懵逼了。不过其实还好吧
    闲着没事干就把他给写了出来。
    我们定义 上面边界 up , 下面边界down, 左边边界left, 右边边界rihgt;
    然后分别 按照次序进行打印就完了。
    效果如下,不过这样好像没有什么实际工程意义, 吐槽~~。
    顺时针打印-2020-10-01-12-55-29
    突然想起 对于未知二位数组指针,可以使用sizeof 进行做除法求取数组的长和宽。
    假设arry是一个int** 类型的 二位数组指针
    可以这样获取行数和列数。
    行数 sizeof(arry) / sizeof(*arry)
    列数 sizeof(*arry) / sizeof(int)

    代码

    话不多说,show me your code

    #include<iostream>
    using namespace std;
    
    int main(){
    
        int arry[8][10] = {0};
    
        int x = sizeof (arry) / sizeof(*arry); // 获取行
        int y = sizeof(*arry) / sizeof(int);   // 获取列
    
        // 顺时针打印。 
        int left = 0, right = y - 1, up = 0, down = x - 1; // 记录 上下左右的边界。
        int cnt = 0; 
        while (left < right && up < down)
        {
            // 打印 上面边界
            for (int i = left; i <= right; i ++ ) arry[up][i] = cnt ++ ;
            up ++ ;
            // 打印 左边列。
            for (int i = up; i <= down; i ++ ) arry[i][right] = cnt ++ ;
            right -- ;
            // 打印 下边界。
            for (int i = right; i >= left; i -- ) arry[down][i] = cnt ++ ;
            down -- ;
            // 打印 右边界
            for (int i = down; i >= up; i -- ) arry[i][left] = cnt ++ ;
            left ++ ;
    
        }
        for (int i = 0; i < 8; i ++ ){
            for (int j = 0; j < 10; j ++ ){
                cout << arry[i][j] <<" ";
            }
            cout << endl;
        }
        system("pause");
        return 0;
    }
    
    

    我的博客传送门
    喜欢的话,给博主赏一杯冰阔乐吧

    展开全文
  • java顺时针遍历矩阵

    千次阅读 2014-03-21 14:50:05
    觉得自己不知道学啥的时候就去面试吧,面完才知道自己有多少不足,分享一个简单的算法题 import java.util.ArrayList;... * 假设一个6x6阶的矩阵 顺时针遍历它  * 1 3 4 2 5 7  * 9 8 1 6 9 8  * 2 1 4 6 7 2  * 0

    觉得自己不知道学啥的时候就去面试吧,面完才知道自己有多少不足,分享一个简单的算法题

    package core; 
    import java.util.ArrayList; 
    import java.util.List; 
    /** 
     * 假设一个6x6阶的矩阵 顺时针遍历它 
     *   1  3  4  2  5  7 
     *   9  8  1  6  9  8 
     *   2  1  4  6  7  2 
     *   0  1  5  7  2  9 
     *   4  6  3  2  7  2 
     *   6  7  2  8  2  5 
     * */ 
    public class NXNTest { 
        private static int[][] data=new int[][]{{1,3,4,2,5,7}, 
                {9,8,1,6,9,8},{2,1,4,6,7,2},{0,1,5,7,2,9},{4,6,3,2,7,2},{6,7,2,8,2,5}}; 
        private static List<Integer> res=new ArrayList<Integer>(); 
         
        /** 
         * 遍历一圈 
         * @param startPoint 起点 
         * @param endPoint 终点 
         * */ 
        public static void oneLap(int startPoint,int endPoint){ 
            for(int i=startPoint;i<=endPoint;i++){ 
                res.add(data[startPoint][i]); 
                if(i==endPoint){ 
                    for(int j=startPoint+1;j<=endPoint;j++){ 
                        res.add(data[j][endPoint]); 
                        if(j==endPoint){ 
                            for(int i2=endPoint-1;i2>=startPoint;i2--){ 
                                res.add(data[endPoint][i2]); 
                                if(i2==startPoint){ 
                                    for(int j2=endPoint-1;j2>startPoint;j2--){ 
                                        res.add(data[j2][startPoint]); 
                                    } 
                                } 
                            } 
                        } 
                    } 
                } 
            } 
        } 
         
        /** 
         * 遍历每一圈 
         * **/ 
        public static void everyLap(int startPoint,int endPoint){ 
            while(startPoint<=endPoint){ 
                System.out.println("start= "+startPoint+" end= "+endPoint); 
                oneLap(startPoint++,endPoint--); 
            } 
        } 
         
        public static void main(String[] args) { 
            everyLap(0, data.length-1); 
            System.out.println(res.toString()); 
        } 
    } 
    


    展开全文
  • 顺时针遍历方阵

    2019-11-20 09:33:26
    思路就是采用递归遍历,先遍历最外圈,然后四角收缩,遍历内圈矩阵,递归的终止条件有两种,一种是中间剩一个元素,一种是中间剩四个元素 代码如下 package r.w.practice; public class MatrixTraverser { public...

    如题:顺时针遍历一个方阵

    昨天去面试,考到了这个题,当时写的不是特别好,回到家重新梳理了一下

    思路就是采用递归遍历,先遍历最外圈,然后四角收缩,遍历内圈矩阵,递归的终止条件有两种,一种是中间剩一个元素,一种是中间剩四个元素

    代码如下

    package r.w.practice;
    
    public class MatrixTraverser {
    
        public static void main(String[] args) {
    
            int[][] matrix = new int[][]{
                    {0, 1, 2, 3},
                    {11, 12, 13, 4},
                    {10, 15, 14, 5},
                    {9, 8, 7, 6}
            };
            new MatrixTraverser().traverse(matrix);
        }
    
        private void traverse(int[][] matrix) {
    
            if (matrix == null
                    || matrix.length == 0
                    || matrix.length != matrix[0].length) {
                throw new IllegalArgumentException("matrix is not valid");
            }
            final int length = matrix.length;
            Point leftUp = new Point(0, 0);
            Point rightUp = new Point(0, length - 1);
            Point rightBottom = new Point(length - 1, length - 1);
            Point leftBottom = new Point(length - 1, 0);
            _traverse(matrix, leftUp, rightUp, rightBottom, leftBottom);
        }
    
        private void _traverse(int[][] matrix, Point leftUp, Point rightUp, Point rightBottom, Point leftBottom) {
    
            if (leftUp.col == rightUp.col) {
                System.out.println(matrix[leftUp.row][leftUp.col]);
                return;
            }
            if (rightUp.col - leftUp.col == 1) {
                System.out.println(matrix[leftUp.row][leftUp.col]);
                System.out.println(matrix[rightUp.row][rightUp.col]);
                System.out.println(matrix[rightBottom.row][rightBottom.col]);
                System.out.println(matrix[leftBottom.row][leftBottom.col]);
                return;
            }
            for (int col = leftUp.col; col <= rightUp.col; col++) {
                System.out.println(matrix[leftUp.row][col]);
            }
            for (int row = rightUp.row + 1; row <= rightBottom.row; row++) {
                System.out.println(matrix[row][rightUp.col]);
            }
            for (int col = rightBottom.col - 1; col >= leftBottom.col; col--) {
                System.out.println(matrix[rightBottom.row][col]);
            }
            for (int row = leftBottom.row - 1; row > leftUp.row; row--) {
                System.out.println(matrix[row][leftBottom.col]);
            }
            _traverse(matrix,
                    new Point(leftUp.row + 1, leftUp.col + 1),
                    new Point(rightUp.row + 1, rightUp.col - 1),
                    new Point(rightBottom.row - 1, rightBottom.col - 1),
                    new Point(leftBottom.row - 1, leftBottom.col + 1)
            );
        }
    
        class Point {
    
            private int row;
    
            private int col;
    
            Point(int row, int col) {
    
                this.row = row;
                this.col = col;
            }
        }
    }
    
    展开全文
  • 顺时针打印矩阵(数组遍历)题目描述结果知识点代码总结 题目描述 输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下4 X 4矩阵: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则...
  • 初学Java,遇到遍历回型数的题,想了好长时间,最后写出来,挺有成就感的,特此分享一下自己的心得,有问题还希望大佬多指正。 遍历回型数主要利用二维数组,个人认为可以将数组分为四部分,由外向内,先从左向右...
  • 顺时针遍历打印数组

    2019-10-24 23:20:28
    二维数组内容 1234 5678 9101112 13141516 输入结果: 1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10 #include <bits/stdc++.h> using namespace std; void PrintMatrix(vector<... ...
  • 矩阵_顺时针遍历

    2020-04-07 23:44:14
    输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下4 X 4矩阵: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10 1 → 2 → 3 ...
  • 顺时针遍历数组

    2015-03-10 13:45:35
    * 顺时针遍历数组 * * @author 承天 * */ public class ClockwiseArray { final int m = 5; final int n = 5; int arr[][] = new int[m][n]; public ClockwiseArray() { int x = 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] 解决 按照顺时针遍历螺旋...
  • 剑指Offer——顺时针遍历矩阵

    千次阅读 2018-03-07 19:04:21
    题目描述:输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下矩阵: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10....
  • //顺时针螺旋遍历数组 private static void rotating(long[] f, long[][] m) { // TODO Auto-generated method stub int k = 1; int n = m.length; int order = f.length-1; for(int i=0;i<=n/2;i++){ ...
  • buttom:矩阵的下边界遍历的顺序:左——右:[left,right] 只有这一个不用另加判断剩余的三个都要另外判断;class Solution { public: vector&lt;int&gt; printMatrix(vector&lt;vector&lt;int&...
  • 给你一个正整数 n ,生成一个包含 1 到 n2 所有元素,且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。 示例 1: 输入:n = 3 输出:[[1,2,3],[8,9,4],[7,6,5]] 示例 2: 输入:n = 1 输出:[[1]] ...
  • 蜗牛——矩阵顺时针遍历

    千次阅读 2014-09-07 11:05:43
    题目:输入一个矩阵,按照从外向里以顺时针顺序依次打印出每一个数字,例如:如果输入如下矩阵: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9,...
  • 有这么一道面试题,让顺时针输出一个二维矩阵。   思路 记录开始行开始列和结束行结束列,做为输出的边界 除了要输出的矩阵,我还设置了一个状态矩阵,用来记录矩阵中某一个元素输出与否,没有输出过的元素,才...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,103
精华内容 5,641
关键字:

顺时针遍历