回形数格式方阵的实现

已于 2022-12-14 11:15:42 修改
阅读量1.1k 收藏 6
点赞数 2
分类专栏： 算法题集锦 文章标签： java 算法
于 2022-12-13 21:14:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41915723/article/details/128308029
版权 

回形数格式方阵的实现
从键盘输入一个整数（1~20）
则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。
例如： 输入数字2，则程序输出：
1 2
4 3
输入数字3，则程序输出：
1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1   2   3   4
12  13  14  5
11  16  15  6
10   9  8   7
输入数字5， 则程序输出：
1   2   3   4   5
16  17  18  19  6
15  24  25  20  7
14  23  22  21  8
13  12  11  10  9


package com.ly.code.day07.work;

import java.util.Scanner;
/* *回形数格式方阵的实现
从键盘输入一个整数（1~20）
则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。
例如： 输入数字2，则程序输出：
1 2
4 3
输入数字3，则程序输出：
1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1   2   3   4
12  13  14  5
11  16  15  6
10   9  8   7
输入数字5， 则程序输出：
1   2   3   4   5
16  17  18  19  6
15  24  25  20  7
14  23  22  21  8
13  12  11  10  9

* */
public class RectangleTest {
    //方法一：
/*
    public static void main(String[] args) {
        Scanner scan =new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int len = scan.nextInt();
        int[][] arr = new int[len][len];

        int s = len * len;
        */
/*
        *k = 1:向右，k = 2:向下，k = 3:向左，k = 4:向上。
        * *//*

        int k = 1;
        int i = 0,j = 0;
        for (int m = 1; m <= s; m++) {
            if (k == 1) {//向右
                //arr[i][j] == 0说明是第一行，i=0。
                if(j < len && arr[i][j] == 0){
                    arr[i][j++] = m;
                }else {
                    k = 2;//向下
                    i++;//行+1
                    j--;//列-1
                    m--;//依次递减
                }
            }else if(k==2){//向下
                if(i < len && arr[i][j] == 0){
                    arr[i++][j] = m;
                }else {
                    k = 3;
                    i--;
                    j--;
                    m--;
                }
            }else if(k == 3){
                if(j >= 0 && arr[i][j] == 0){
                    arr[i][j--] = m;
                }else {
                    k = 4;
                    i--;
                    j++;
                    m--;
                }
            }else if(k == 4){//向上
                if(i >= 0 && arr[i][j] == 0){
                    arr[i--][j] = m;
                }else {
                    k = 1;
                    i++;
                    j++;
                    m--;
                }
            }
        }
        //遍历
        for (int m = 0; m < arr.length; m++) {
            for (int n = 0; n < arr[m].length; n++) {
                System.out.print(arr[m][n] + "\t");
            }
            System.out.println();//换行
        }
    }
*/
    //方法二：

    public static void main(String[] args) {
        int n =6;
        int[][] arr = new int[n][n];

        int count = 0;//要显示的数据
        int maxL = n - 1;//行的最大下标x
        int maxH = n - 1;//列的最大下标y
        int minL = 0;//行的最小下标
        int minH = 0;//列的最小下标
        while(minL <= maxL){//行和列一直再往中间靠近，靠近中心点。而中心点的 最小列增长 接近 逐渐减小的最大列 。
            //向右
            for (int l = minL; l <= maxL; l++){
                //上面第一行,列改变
                arr[minH][l] = ++count;//++count，count先自增一，再赋值。 count=1；
            }
            //第一行结束，最小行要+1；
            minH++;

            //向下
            for(int h = minH; h <= maxH; h++){
                //右边最后一列
                arr[h][maxL] = ++count;
            }
            //最后一列结束，最大列要-1；
            maxL--;

            //向左
            for (int l = maxL; l >= minL ; l--) {
                //最后一行
                arr[maxH][l] = ++count;
            }
            //最后一行结束，行要-1；
            maxH--;

            //向上
            for (int h = maxH; h >=minH ; h--) {
                //最左一列
                arr[h][minL] = ++count;
            }
            //最左一列结束，列要+1；
            minL++;
        }

/*      int n =4;
        int[][] arr = new int[n][n];

        int count = 0;//要显示的数据
        int maxX = n - 1;//x轴的最大下标
        int maxY = n - 1;//y轴的最大下标
        int minX = 0;//x轴的最小下标
        int minY = 0;//y轴的最小下标
        while (minX <= maxX){
            for (int x = minX; x <= maxX; x++) {
                arr[minY][x] = ++count;
            }
            minY++;
            for (int y = minY; y <= maxY; y++) {
                arr[y][maxX] = ++count;
            }
            maxX--;
            for (int x = maxX; x >= minX; x--) {
                arr[maxY][x] = ++count;
            }
            maxY--;
            for (int y = maxY; y >= minY; y--) {
                arr[y][minX] = ++count;
            }
            minX++;
        }

        */
        //遍历
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                String space = (arr[i][j] + "").length() == 1 ? "0" : "";
                System.out.print(space + arr[i][j] + " ");
            }
            System.out.println();//换行
        }
    }




}

输出结果：

01 02 03 04 05 06 
20 21 22 23 24 07 
19 32 33 34 25 08 
18 31 36 35 26 09 
17 30 29 28 27 10 
16 15 14 13 12 11 

修改版：

package com.ly.code.day07.work;

import java.util.Scanner;
/* *回形数格式方阵的实现
从键盘输入一个整数（1~20）
则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。
例如： 输入数字2，则程序输出：
1 2
4 3
输入数字3，则程序输出：
1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1   2   3   4
12  13  14  5
11  16  15  6
10   9  8   7
输入数字5， 则程序输出：
1   2   3   4   5
16  17  18  19  6
15  24  25  20  7
14  23  22  21  8
13  12  11  10  9

* */
public class RectangleTest {
    //方法一：
/*
    public static void main(String[] args) {
        Scanner scan =new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int len = scan.nextInt();
        int[][] arr = new int[len][len];

        int s = len * len;
        */
/*
        *k = 1:向右，k = 2:向下，k = 3:向左，k = 4:向上。
        * *//*

        int k = 1;
        int i = 0,j = 0;
        for (int m = 1; m <= s; m++) {
            if (k == 1) {//向右
                //arr[i][j] == 0说明是第一行，i=0。
                if(j < len && arr[i][j] == 0){
                    arr[i][j++] = m;
                }else {
                    k = 2;//向下
                    i++;//行+1
                    j--;//列-1
                    m--;//依次递减
                }
            }else if(k==2){//向下
                if(i < len && arr[i][j] == 0){
                    arr[i++][j] = m;
                }else {
                    k = 3;
                    i--;
                    j--;
                    m--;
                }
            }else if(k == 3){
                if(j >= 0 && arr[i][j] == 0){
                    arr[i][j--] = m;
                }else {
                    k = 4;
                    i--;
                    j++;
                    m--;
                }
            }else if(k == 4){//向上
                if(i >= 0 && arr[i][j] == 0){
                    arr[i--][j] = m;
                }else {
                    k = 1;
                    i++;
                    j++;
                    m--;
                }
            }
        }
        //遍历
        for (int m = 0; m < arr.length; m++) {
            for (int n = 0; n < arr[m].length; n++) {
                System.out.print(arr[m][n] + "\t");
            }
            System.out.println();//换行
        }
    }
*/
    //方法二：

    public static void main(String[] args) {
        Scanner scan =new Scanner(System.in);
        System.out.println("请输入一个数字：");
        int n = scan.nextInt();
        int[][] arr = new int[n][n];

        int count = 0;//要显示的数据
        int maxL = n - 1;//行的最大下标x
        int maxH = n - 1;//列的最大下标y
        int minL = 0;//行的最小下标
        int minH = 0;//列的最小下标
        while(minL <= maxL){//行和列一直再往中间靠近，靠近中心点。而中心点的 最小列增长 接近 逐渐减小的最大列 。
            //向右
            for (int l = minL; l <= maxL; l++){
                //上面第一行,列改变
                arr[minH][l] = ++count;//++count，count先自增一，再赋值。 count=1；
            }
            //第一行结束，最小行的值要+1；
            minH++;

            //向下
            for(int h = minH; h <= maxH; h++){
                //右边最后一列
                arr[h][maxL] = ++count;
            }
            //最后一列结束，最大列的值要-1；
            maxL--;

            //向左
            for (int l = maxL; l >= minL ; l--) {
                //最后一行
                arr[maxH][l] = ++count;
            }
            //最后一行结束，最后一行的值要-1；
            maxH--;

            //向上
            for (int h = maxH; h >=minH ; h--) {
                //最左一列
                arr[h][minL] = ++count;
            }
            //最左一列结束，最左一列的值要+1；
            minL++;
        }

/*      int n =4;
        int[][] arr = new int[n][n];

        int count = 0;//要显示的数据
        int maxX = n - 1;//x轴的最大下标
        int maxY = n - 1;//y轴的最大下标
        int minX = 0;//x轴的最小下标
        int minY = 0;//y轴的最小下标
        while (minX <= maxX){
            for (int x = minX; x <= maxX; x++) {
                arr[minY][x] = ++count;
            }
            minY++;
            for (int y = minY; y <= maxY; y++) {
                arr[y][maxX] = ++count;
            }
            maxX--;
            for (int x = maxX; x >= minX; x--) {
                arr[maxY][x] = ++count;
            }
            maxY--;
            for (int y = maxY; y >= minY; y--) {
                arr[y][minX] = ++count;
            }
            minX++;
        }

        */
        //遍历
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                //arr[i][j] + ""，把数组变成了一个字符串，然后计算长度，就可以看出是个位数还是几位数！！！
                String space = (arr[i][j] + "").length() == 1 ? "0" : "";
                System.out.print(space + arr[i][j] + " ");
            }
            System.out.println();//换行
        }
        //10以上的数字出现三位数，可以排列出三位添加
        //遍历
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length; j++) {
                //arr[i][j] + ""，把数组变成了一个字符串，然后计算长度，就可以看出是个位数还是几位数！！！
                String space ="";
                if(n>=10){
                    if((arr[i][j] + "").length() == 1){
                        space ="00";
                    }else if((arr[i][j] + "").length() == 2){
                        space ="0";
                    }else if((arr[i][j] + "").length() == 3){
                        space ="";
                    }
                }else {
                    space = (arr[i][j] + "").length() == 1 ? "0" : "";
                }
                System.out.print(space + arr[i][j] + " ");
            }
            System.out.println();//换行
        }


        int b[][] = new int[3][3];
        b[0][1] = 2;
        b[0][2] = 22;
        b[1][0] = 265;
        System.out.println((b[0][1]+"").length());
        System.out.println((b[0][2]+"").length());
        System.out.println((b[1][0]+"").length());





    }






}

输出结果：


请输入一个数字：
19
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 20 
71 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 90 21 
70 135 192 193 194 195 196 197 198 199 200 201 202 203 204 205 152 91 22 
69 134 191 240 241 242 243 244 245 246 247 248 249 250 251 206 153 92 23 
68 133 190 239 280 281 282 283 284 285 286 287 288 289 252 207 154 93 24 
67 132 189 238 279 312 313 314 315 316 317 318 319 290 253 208 155 94 25 
66 131 188 237 278 311 336 337 338 339 340 341 320 291 254 209 156 95 26 
65 130 187 236 277 310 335 352 353 354 355 342 321 292 255 210 157 96 27 
64 129 186 235 276 309 334 351 360 361 356 343 322 293 256 211 158 97 28 
63 128 185 234 275 308 333 350 359 358 357 344 323 294 257 212 159 98 29 
62 127 184 233 274 307 332 349 348 347 346 345 324 295 258 213 160 99 30 
61 126 183 232 273 306 331 330 329 328 327 326 325 296 259 214 161 100 31 
60 125 182 231 272 305 304 303 302 301 300 299 298 297 260 215 162 101 32 
59 124 181 230 271 270 269 268 267 266 265 264 263 262 261 216 163 102 33 
58 123 180 229 228 227 226 225 224 223 222 221 220 219 218 217 164 103 34 
57 122 179 178 177 176 175 174 173 172 171 170 169 168 167 166 165 104 35 
56 121 120 119 118 117 116 115 114 113 112 111 110 109 108 107 106 105 36 
55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 
001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 
072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 020 
071 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 090 021 
070 135 192 193 194 195 196 197 198 199 200 201 202 203 204 205 152 091 022 
069 134 191 240 241 242 243 244 245 246 247 248 249 250 251 206 153 092 023 
068 133 190 239 280 281 282 283 284 285 286 287 288 289 252 207 154 093 024 
067 132 189 238 279 312 313 314 315 316 317 318 319 290 253 208 155 094 025 
066 131 188 237 278 311 336 337 338 339 340 341 320 291 254 209 156 095 026 
065 130 187 236 277 310 335 352 353 354 355 342 321 292 255 210 157 096 027 
064 129 186 235 276 309 334 351 360 361 356 343 322 293 256 211 158 097 028 
063 128 185 234 275 308 333 350 359 358 357 344 323 294 257 212 159 098 029 
062 127 184 233 274 307 332 349 348 347 346 345 324 295 258 213 160 099 030 
061 126 183 232 273 306 331 330 329 328 327 326 325 296 259 214 161 100 031 
060 125 182 231 272 305 304 303 302 301 300 299 298 297 260 215 162 101 032 
059 124 181 230 271 270 269 268 267 266 265 264 263 262 261 216 163 102 033 
058 123 180 229 228 227 226 225 224 223 222 221 220 219 218 217 164 103 034 
057 122 179 178 177 176 175 174 173 172 171 170 169 168 167 166 165 104 035 
056 121 120 119 118 117 116 115 114 113 112 111 110 109 108 107 106 105 036 
055 054 053 052 051 050 049 048 047 046 045 044 043 042 041 040 039 038 037 
1
2
3

时时师师
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字旋转方阵
weixin_51298205的博客
11-08 1255
数字旋转方阵
输出“回”型数字方阵
bigod18的博客
03-26 2031
首先，我们的主要思路就是，用一个标志来描述下一步走的方向，按顺时针方向依次为右、下、左、上。然后用一个循环把n*n方阵填满，最后输出即可。题目：对于给定的输入n；按顺时针方向输出一个边长为n的“回”型数字方阵。
算法设计与分析:分治法输出数字旋转方阵
Nylon_Min的博客
04-02 3837
分治法输出数字旋转方阵 数字旋转方阵如下图所示： 从下图可以看出，从左上角开始，逆时针放置每次增加1的数字，直到“旋转”到最里层终止。 分治：将这个矩阵填数之时一层一层地填进去，也就是说子问题就是每次填写一层。 代码如下： #include "stdafx.h" #include<iostream> #include <iomanip> using namespace ...
分治算法——数字旋转矩阵
weixin_45927758的博客
10-18 672
这道题以前就写过，使用的是循环以及判断，最近学习了分治的思想，这个思想其实以前学习归并的时候就大概有个体会，但是最近系统学习了这个思想，有了更加体系的思想。 #include<vector> #include<iostream> using namespace std; void Helix_matrix(vector<vector<int>>&mtx,int begin,int size,int number) { if(size==.
数字旋转方阵c语言主函数,数据结构——递归求数字旋转方阵
weixin_39817391的博客
05-20 1616
【数字旋转方阵问题】问题描述：输出下图所示N×N(N≥1)的数字旋转方阵。要求：采用递归法实现。提示：注意观察A、B、C、D四个区域。void FillInNum(int number, int begin, int MatrixSize){ // 从数字number开始填写, 例如从1开始填写；// MatrixSize为N维方阵，第一个填充的左上角的下标为(begin, begin)/网上...
数字旋转方阵 分治法——C++代码
06-08
课程的随堂作业，C语言的，用dev就能运行，萌新代码，勿喷，仅仅帮助不想写作业的朋友方便一下，反正老师也不会仔细检查的
NOIP资料_数字方阵
05-08
详细介绍了NOIP竞赛辅导中二维数组打印各种数字方阵的实现方法
数字旋转方阵（java）
06-29
在本实验中，任务是创建一个Java程序，用于输出顺时针旋转的数字方阵。这个方阵的特性是从中心开始，数字按照顺时针方向填充。给定的代码片段是用C++编写的，但我们可以将其转换为Java语言，并解释其工作原理。 ...
回形填数（蛇形填数）
05-07
述 在n*n方陈里填入1,2,...,n*n,要求填成蛇形。例如n=4时方陈为： 10 11 12 1 9 16 13 2 8 15 14 3 7 6 5 4 输入 直接输入方陈的维数，即n的值。(n) 输出 输出结果是蛇形方陈。
方阵顺时针旋转的实现代码
09-05
以下是关于方阵顺时针旋转的实现代码。需要的朋友参考下
JAVA回字方阵
09-17
用JAVA写的一个回字型方针。课堂作业。
C语言回型矩阵
09-14
用C语言实现输入任意一个数字，然后以回型矩阵的形式显示出来，其中用数字填充回型矩阵，没有采用递归算法，而是简单判断条件然后循环至结束
C++回型矩阵
09-14
用C++编写的回型矩阵，任意输入一个数字，然后以回型矩阵的形式显示出来
Java数组练习Demo
weixin_45505597的博客
10-05 579
回形数格式方阵的实现 从键盘输入一个整数（1~20） 则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2 4 3 输入数字3，则程序输出： 1 2 3 8 9 4 7 6 5 输入数字4， 则程序输出： 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7 public static void main(String[] args) { int n = 7; int[]
回形方阵.
qq_40713201的博客
03-21 2378
题目描述 ​ 输入一个正整数n，输出n×n的回形方阵。例如，n=5时，输出： 1 1 1 1 1 1 2 2 2 1 1 2 3 2 1 1 2 2 2 1 1 1 1 1 1 输入 ​ 一行一个正整数n，2≤n≤9​。 输出 ​ 共n行，每行包含n个正整数，之间用一个空格隔开。 样例输入 5 样例输出 1 1 1 1 1 1 2 2 2 1 1 2 3 2 1 1 2 2 2 1 1 1 1 1 1 数据规模与约定 ​ 时间限制：1 s ​ 内存限制：256 M ​ 100% 的数据保证2≤n≤9。
JAVA基础-尚硅谷-数组练习题-回形数格式方阵功能实现
IdleTimeLearingblogs
02-15 295
回形数格式方阵功能实现： 代码如下： 第一种方法： //输出回形数 import java.util.Scanner; public class HuiXingShuTest { public static void main(String[] args) { System.out.print("请输入一个数："); Scanner scan = new Scanner(System.in); //从键盘获取一个数 int num = scan.nextInt(); int k = 1
矩阵的输入输出
qq_74190188的博客
04-30 2306
输出一个n*n阶回形矩阵。输出一个n*n阶蛇形矩阵。用从1开始的正整数“蛇形”填充无限大的矩阵。
【Python】从键盘输入n，输出方阵。如n=5
weixin_44821492的博客
10-21 2311
【Python】从键盘输入n，输出方阵。如n=5
java方阵 回形取数
最新发布
10-11
你可以按照以下的方式来实现一个Java方阵回形取数的算法： ```java public class MatrixSpiralTraversal { public static void main(String[] args) { int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; spiralTraversal(matrix); } public static void spiralTraversal(int[][] matrix) { int top = 0; int bottom = matrix.length - 1; int left = 0; int right = matrix[0].length - 1; while (top <= bottom && left <= right) { // Traverse top row for (int i = left; i <= right; i++) { System.out.print(matrix[top][i] + " "); } top++; // Traverse right column for (int i = top; i <= bottom; i++) { System.out.print(matrix[i][right] + " "); } right--; if (top <= bottom) { // Traverse bottom row for (int i = right; i >= left; i--) { System.out.print(matrix[bottom][i] + " "); } bottom--; } if (left <= right) { // Traverse left column for (int i = bottom; i >= top; i--) { System.out.print(matrix[i][left] + " "); } left++; } } } } ``` 这个算法使用了四个指针，分别代表当前要遍历的上下左右边界。在每一步中，按照顺时针的方向遍历矩阵的边界，并将遍历到的元素输出。通过不断调整边界的位置，直到遍历完所有元素。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值