精华内容
下载资源
问答
  • 在上图中,我们设置二维数组宽度为rows,高度为columns,取左上角坐标为(startX,startY),取左下角的坐标为(endX,endY),可以发现 每次循环的开始为(startX,startY),endX和endY可以根据rows和columns来推出...

    如下图


     当我们遇到一个复杂问题时可以用图像帮我们思考

    在上图中,我们设置二维数组宽度为rows,高度为columns,取左上角坐标为(startX,startY),取左下角的坐标为(endX,endY),可以发现

    每次循环的开始为(startX,startY),endX和endY可以根据rows和columns来推出,所以我们应该去发现(startX,startY)的规律

    我们来分析循环结束的条件。

    对一个rows为2,columns为2的二维数组,最后一次打印startX = 0、startY= 0。

    对一个rows为3,columns为3的二维数组,最后一次打印startX = 1、startY= 1。

    对一个rows为4,columns为4的二维数组,最后一次打印startX = 1、startY= 1。

    对一个rows为5,columns为5的二维数组,最后一次打印startX = 2、startY= 2。

    对一个rows为6,columns为6的二维数组,最后一次打印startX = 2、startY= 2。

    我们可以得出 让循环继续的条件为

    startX * 2 < rows && startY * 2 < columns

    这些条件我们大概可以把循环体定下来了


    接下来我们来分析循环体中的顺时针打印


    // 第一步,从左到右打印一行
    PrintRowIncreasingly

    // 第二步,从上到下打印一列
    printColumnIncreasingly

    // 第三步,从右到左打印一行
    printRowDecreasingly

    // 第四步,从下到上打印一列

    printColumnDecreasingly

    该传那些参数,判断执行的条件,具体如下

    /*
     * 如以下矩阵
     * 输入 4 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
     * 
     * 类似的
     * 输入2 3
     * 初始化为
     *  1   2   3
     *  4   5   6
     *  依次输出1,2,3,6,5,4
     * 输入3 2
     * 初始化为
     * 	1   2
     *  3   4
     *  5   6
     *  依次输出1,2,4,6,5,3
     */
    public class HelixMatrix01 {
    
    	public static void main(String[] args) {
    		Scanner scan = new Scanner(System.in);
    		int n = scan.nextInt();
    		int m = scan.nextInt();
    		int arr[][] = new int[n][m];
    		initArr(arr);
    		printArr(arr);
    	}
    
    	private static void printArr(int arr[][]) {
    		int startX = 0;
    		int startY = 0;
    		int endX = 0;
    		int endY = 0;
    		int rows = arr.length;
    		int columns = arr[0].length;
    		while (startX * 2 < rows && startY * 2 < columns) {
    			endX = arr[0].length - 1 - startX;
    			endY = arr.length - 1 - startY;
    			// 第一步,从左到右打印一行
    			PrintRowIncreasingly(arr, startX, endX, startY);
    			// 第二步,从上到下打印一列
    			if (startY < endY) {    	//当剩余行数多于或等于两行时
    				printColumnIncreasingly(arr, endX, startY + 1, endY);
    			}
    			// 第三步,从右到左打印一行
    			if(endX>startX){			//当剩余列数多余或等于两行时
    				printRowDecreasingly(arr, endX - 1, startX, endY);
    			}
    			// 第四步,从下到上打印一列
    			if(endY-1 > startY)
    			printColumnDecreasingly(arr, startX, endY-1, startY + 1);
    			startX++;
    			startY++;
    		}
    	}
    
    	private static void PrintRowIncreasingly(int arr[][], int startX, int endX, int startY) {
    		for (int i = startX; i <= endX; ++i) {
    			System.out.print(arr[startY][i] + " ");
    		}
    	}
    	private static void printColumnIncreasingly(int arr[][], int endX, int startY, int endY) {
    		for (int j = startY; j <= endY; ++j) {
    			System.out.print(arr[j][endX] + " ");
    		}
    	}
    	private static void printRowDecreasingly(int arr[][], int startX, int endX, int endY) {
    		for (int i = startX; i >= endX; --i) {
    			System.out.print(arr[endY][i] + " ");
    		}
    	}
    	private static void printColumnDecreasingly(int arr[][], int startX, int startY, int endY) {
    		for (int j = startY; j >= endY; --j) {
    			System.out.print(arr[j][startX] + " ");
    		}
    	}
    
    	private static void initArr(int arr[][]) {
    		int temp = 1;
    		for (int i = 0; i < arr.length; ++i) {
    			for (int j = 0; j < arr[0].length; ++j) {
    				arr[i][j] = temp++;
    			}
    		}
    //		for(int i=0; i<arr.length; i++){
    //			for(int j=0; j<arr[0].length; j++){
    //				System.out.print(arr[i][j]+" ");
    //			}
    //			System.out.println();
    //		}
    	}
    
    }
    



    对一个rows为3,columns为3的二维数组,最后一次打印startX = 1、startY= 1。
    展开全文
  • 螺旋打印二维数组。 解题思路: 问题点:怎么构建一个螺旋的二维数组 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7 分析: 1、构建一个二维数组,按照顺时针的方向依次填入矩阵中1、2、3、4、5、6、7、8、9...

    题目:

    螺旋打印二维数组。

    解题思路:

    问题点:怎么构建一个螺旋的二维数组

    1     2     3    4

    12  13  14    5

    11   16  15   6

    10   9     8    7

    分析:

    1、构建一个二维数组,按照顺时针的方向依次填入矩阵中1、2、3、4、5、6、7、8、9……

    • 问题拆分:
    • 先搞最外面一层,再搞下一层,依次类推,直到数组被填充完,重点是怎么判断边界和方向

    2、边界判断

    • 矩阵:matrix;矩阵大小:n(n*n矩阵全部初始化为0);行:i表示; 列:j表示(i=0, j=0);方向:上下左右
    • 边界判断:
    • 右边界:matrix[ i ][ j+1 ] == 0; // 行i不变,列j每次+1(==0说明不到右边界,如果到了右边界,行i+1,列不变,方向改成下)

    • 下边界:matrix[ i+1 ][ j ] == 0; // 行i每次+1,列j不变(==0说明不到下边界,如果到了下边界,行不变,列j-1,方向改成左)

    • 左边界:matrix[ i ][ j-1 ] == 0; //行i不变,列j每次-1(==0说明不到左边界,如果到了左边界,行i-1,列j不变,方向改成上)

    • 上边界:matrix[ i-1 ][ j ] == 0; //行每次-1,列不变(==0说明不到上边界,如果到了上边界,行不变,列j+1,方向改成右)

    
    public class Untitled {
        public static void main(String []args) {
    		int n = 4;
    		int[][] matrix = new int[n][n];
    		int right = 1, down = 2, left = 3, up = 4;
    		int direction = right;
    		int i = 0, j = 0;
    		int step = 0;
    		for(step = 1; step <= n*n; step ++){
    			matrix[i][j] = step;
    			
    			// 左 - 右
    			if(direction == right){
    				if(j+1 < n && matrix[i][j+1] == 0){
    					j ++;
    				}else{
    					i ++;
    					direction = down;
    					continue;
    				}
    			}
    			
    			// 上 - 下
    			if(direction == down){
    				if(i + 1 < n && matrix[i+1][j] == 0){
    					i ++;
    				}else{
    					j --;
    					direction = left;
    					continue;
    				}
    			}
    			
    			// 右 - 左
    			if(direction == left){
    				if(j - 1 >= 0 && matrix[i][j-1] == 0){
    					j --;
    				}else{
    					i --;
    					direction = up;
    					continue;
    				}
    			}
    			
    			// 下 - 上
    			if(direction == up){
    				if(i - 1 >= 0 && matrix[i-1][j] == 0){
    					i --;
    				}else{
    					j ++;
    					direction = right;
    					continue;
    				}
    			}
    		}
    		
    		for(int row = 0; row < n; row ++){
    			for(int col = 0; col < n; col ++){
    				System.out.print(matrix[row][col]);
    				System.out.print("\t");
    			}
    			System.out.println();
    		}
    		
        }
    }

     

    展开全文
  • 顺时针打印二维数组

    千次阅读 2018-09-19 19:42:38
    给定一个N*N的整型二维数组,要求以(0,0)为起点,由外层向内层,按顺时针方向依次输出全部元素,如下数组的输出应为1,2,3,6,9,8,7,4,5. 1 2 3 4 5 6 7 8 9 解题思路 顺时针输出全部元素,第一步就要先打印出第一行...

    顺时针输出二维数组

    最近面试,做了这样一道题目:
    给定一个N*N的整型二维数组,要求以(0,0)为起点,由外层向内层,按顺时针方向依次输出全部元素,如下数组的输出应为1,2,3,6,9,8,7,4,5.
    1 2 3
    4 5 6
    7 8 9

    解题思路

    顺时针输出全部元素,第一步就要先打印出第一行元素(即array[0][0]~array[0][n-1]);
    第二步打印出最后一列元素(即array[1][n-1]~array[n-1][n-1]);
    第三步打印出最后一行(即array[n-1][n-2]~array[n-1][0]);
    第四步打印出第一列(即array[0][n-2]~array[1][0]).
    至此,已经将二维数组的最外围打印出来了,将最外围的数组元素去除之后,可以发现里面的数组是一个新的二维数组,所以,可以用递归来实现。

    代码主要实现:

    public static void clockWise(int[][] data) {
            //行长度
            int row = data.length;
            //列长度
            int column = 0;
            for (int i = 0; i < row; i++) {
                column = data[i].length;
            }
            //若N*N二维数组只有一个元素时
            if (row == 1 && column == 1) {
                System.out.print(data[row - 1][column - 1] + " ");
                return;
            }
            //打印第一行
            for (int i = 0; i < column; i++) {
                System.out.print(data[0][i] + " ");
            }
            //打印最后一列
            for (int i = 1; i < row; i++) {
                System.out.print(data[i][column - 1] + " ");
            }
            //打印最后一行
            for (int i = column - 2; i >= 0; i--) {
                System.out.print(data[row - 1][i] + " ");
            }
            //打印第一列
            for (int i = row - 2; i >= 1; i--) {
                System.out.print(data[i][0] + " ");
            }
            //若行、列还有元素未打印
            if (row - 2 > 0 && column - 2 > 0) {
                //构造新的二维数组
                int array[][] = new int[row - 2][column - 2];
                for (int i = 1; i <= row - 2; i++) {
                    for (int j = 1; j <= column - 2; j++) {
                        array[i - 1][j - 1] = data[i][j];
                    }
                }
                //递归
                clockWise(array);
            }
        }
    

    输出

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

    总结

    做这道题时,我认为不仅仅只为了写出这道题来,如果只是单单解出一个3行3列的二维数组,有很多种通解,可是应对的只是3行3列的二维数组,可是如果是4行4列、5行5列…以及矩形二维数组,原先的代码就不一定能实现了。总之,编程需要多思考,多多优化自己的代码,可以学会很多东西…

    展开全文
  • 顺时针打印二维数组

    题目描述
    输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下矩阵: 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.

    解题思路:
    大家都知道一个矩阵只需要知道左上角和右下角坐标就可以得到它的大小,所以首先取矩阵的左上角和右下角坐标分别记为:

    int x_top = 0;int y_top = 0; 
    int x_bottom = row - 1;int y_bottom = col - 1;//row为矩阵行,col为矩阵列

    整个过程可分为:从左到右打印数组、从上到下打印、从右到左、从下到上。通过上述四个位置变量来控制打印,没打印一圈,x_top++;y_top++;x_bottom–;y_bottom–;意思就是往矩阵中心缩进一步,当两个坐标点重合时,即到最后一个数字,遍历结束。

    private static ArrayList<Integer> pMatrix(int[][] matrix) {
        int col = matrix[0].length;// 列数
        int row = matrix.length;// 行数
        ArrayList<Integer> resultList = new ArrayList<>();
        if(col == 0 || row == 0){
            return resultList;
        }
        int x_top = 0;int y_top = 0;//矩阵左上点和右下点
        int x_bottom = row - 1;int y_bottom = col - 1;
        while(x_top <= x_bottom && y_top <= y_bottom){
            //左边到右边=>行不变,列变
            for(int i = y_top;i <= y_bottom;i++) resultList.add(matrix[x_top][i]);
            //上到下=>列不变,行变
            for(int i = x_top + 1;i <= x_bottom;i++) resultList.add(matrix[i][y_bottom]);
            //右到左=>行不变,列变
            if (x_top != x_bottom)
            {
                for(int i = y_bottom - 1; i >= y_top; --i)  
                    resultList.add(matrix[x_bottom][i]);
            }
            //下到上=>列不变,行变
            if(y_top != y_bottom)
            {
                for(int i = x_bottom - 1; i > x_top; --i) 
                    resultList.add(matrix[i][y_top]);
            }
            x_top++;y_top++;x_bottom--;y_bottom--;
    
        }
        return resultList;
    }
    展开全文
  • 按照顺时针旋转的方式,打印输出二维数组 可以采用递归的方式,先打印最外围一圈,然后依次向内打印 public class printJuZhen { public static void print(int [][]array,int start,int end){ if (start > ...
  • 1. [顺时针打印二维数组]输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下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...
  • 二维数组及遍历

    万次阅读 多人点赞 2019-09-12 17:41:23
    二维数组及遍历 概念 初始化方式详解 遍历 我在前面的博文详细说过一维数组的概念初始化方式及遍历,今天这篇博文,可以看过前面博文的会很容易接受,前置博文,请直接点击链接跳转。 什么是二维数组二维数组和...
  • public class test { ... // 学会二维数组的定义,初始化,循环赋值 // 用第一种方法定义二维数组 int intArray[][]; // 用第二种方法定义二维数组 int[] intArray1[]; // 用第三种方法定义二维数...
  • 将浏览记录从一维数组型处理成二维数组,删除多条记录后在根据返回的一维数组数据追加到二维数组中 前端小白,在做浏览记录时后台返回的按照时间(年月日格式)排列的一维数组,前台需要处理后展示在页面上,选中...
  • 例如如下的二维数组 var arr = [][]int{ {1, 2, 3, 4, 5, 6}, {7, 8, 9, 10, 11, 12}, {13, 14, 15, 16, 17, 18}, {19, 20, 21, 22, 23, 24}, } 依次打印1,2,3,4,5,6,11,16,21,20,19,13,7,8,9,...
  • 按照从外到里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下矩阵:1 2 3 45 6 7 89 10 11 1213 14 15 16则依次打印数字:1、2、3、4、8、12、16、15、14、13、9、5、6、7、11、10、解题思路结合画图说明...
  • 【说明】在现实中,我们经常使用如下的一个二层循环的方式就可以直接来遍历一个二维数组,并且也没有必要使用其他的方式。但是非要用一层循环来遍历二维数组,也是可以实现的。这个完全可以用来锻炼一下自己的思维,...
  • * 输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字, * 例如,如果输入如下矩阵: 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 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. 解题思路 先得到...
  • 我们在一维数组中已经用了很多的内容进行讲解,那么对于二维数组来说二维数组的本质,也是一维数组,只不过,一维数组中的每个元素,又是一个一维数组而己。 定义 我们首先定义一个二维数组然后进行解释: int array...
  • 新手小白学JAVA 数组 数组工具类 二维数组

    万次阅读 多人点赞 2021-04-02 08:28:55
    1 数组 1.1 概念 数组Array,标志是[ ] ,用于储存多个相同类型数据的集合 想要获取数组中的元素值,可以通过脚标(下标)来获取 数组下标是从0开始的,下标的最大值是数组的长度减1 1.2 创建数组 数组的创建方式一般...
  • Java二维数组的使用

    万次阅读 多人点赞 2018-09-09 16:05:35
    在Java当中二维数组是比较有意思的,很多时候会搞不懂这个二维数组。下面来简单介绍一下二维数组二维数组就是数组中的元素是数组。 二维数组的定义:以int类型举例 int [][]scores;//定义一个int类型的二维...
  • 二维数组右上左下遍历 查看提交统计提问 总时间限制: 1000ms 内存限制: 65536kB 描述 给定一个row行col列的整数数组array,要求从array[0][0]元素开始,按从左上到右下的对角线顺序遍历...
  • 1.一维数组 1.使用数组定义多个变量可以类比于for循环定义,相较而言,使用数组定义已知数量的多个变量操作更加简单,代码更少. 2.数组本身就是一个变量,只是数组存储了一组数据类型相同的数据,同一数组中输入不同...
  • 通过本任务就是来使用二维数组解决这样的问题,这一任务找中将会学到,二维数组的声明初始化以及引用,读者应该能够熟练声明二维数组,运用二维数组。 学习目标 掌握二维数组的定义。 掌握二维数组的初始化。 掌握...
  • 顺时针打印二维数组: 输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下矩阵: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 则依次打印出数字1 2 3 4 5 10 15 ...
  • 对于这个问题我本人不清楚的地方是,我这个程序最后输出的结果好像是他的地址,所以我这个程序需要做怎样的修改才能正确的做出这道题目。 #include #define M 3 #define N 4 int main() ...}
  • 前言 是突然想到的方法,可能早有大佬想过这样的方法,但我还是记录下来,路过的各位就当看个新鲜。 首先是寻常的遍历方法 ...我们遍历一维数组,正常的...二维数组亦是一样依次访问下标来遍历数组,只不过此时要定.
  • 一维数组、二维数组

    2017-12-02 13:58:00
    前面说到过一维数组的基本样式,但是好多人未必知道一维数组到底能干嘛,只知道那是一个循环语句。那么下面一步步解析。先看效果图。 这是一个数学的九九乘法表。不陌生吧? 代码如下:绿色注释看看。 是不是...
  • 二维数组的小秘密

    2016-08-04 19:00:03
    相信大家对于一维数组有一定的了解,那么什么是二维数组呢? 数组可以看做一行连续的数据,只有一个下标的称为一维数组,那么可以猜想多维数组有多个下标,其实就是如此,所以这里要讲的二维数组就是有两个下标的...
  • 维数组 一位数组是最简单的数组类型,它的定义形式如下: 类型说明符 数组名[常量表达式] 类型说明符是数组中每个元素的类型,常量表达式是数组元素的个数 在使用一维数组的时候需要留意以下两个要点 常量表达式...
  • 二维数组打印: 有一个二维数组(n*n),写程序实现从右上角到左下角沿主对角线方向打印。 给定一个二位数组arr及题目中的参数n,请返回结果数组。 测试样例: [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]],4 ...
  • 二维数组和指针

    2017-08-21 20:39:00
    二维数组在内存中的存储,是按照先行后列依次存放的。从内存的角度看,可以这样说,二维数组其实就是一个一维数组,在内存中没有二维的概念。如果把二维数组的每一行看成一个整体,即看成一个数组中的一个元素,那么...
  • 重温C语言 | 二维数组

    2019-07-10 00:29:09
    二维数组: 矩阵的表示形式 多个一维数组组成二维数组 二维数组的定义: 定义格式:数据类型 数组名[长度1] [长度2] 数据类型:表示数组中元素的类型 长度1 : 表示二维数组的行数 长度2 : 表示二维数组的列数 说明...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,067
精华内容 7,626
关键字:

依次打印二维数组