java数组基础算法题-回形数格式方阵的实现、

题目

1. 创建长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值。同时，要求元素的值各不相同。
2. 回形数格式方阵的实现

从键盘输入一个整数（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

第一题

思路解析：
要求创建一个长度为6的int型数组，其中存入0~30不同的int型数据。
可以采用Math.random生成随机数。
控制每个数据值不同，第一个数一定与其余值不同，所以只需要判断后5个数据的值不同即可，每次判断如果有相同，则从新生成随机数再次从新比较。

代码实现

package com.ArraysDome;

import java.util.Arrays;
/**
 * 数组算法题
 *
 * @Author Zhao
 * @Date 2021/4/25 21:07
 * @Version 1.0
 */
public class AlgorithmDome2 {
    /**
     *要求:创建一一个长度为6的int型数组。要求数组元素的值都在1-30之间，且是随机赋值。同时,要求
     * 元素的值各不相同。
     */
    public static void main(String[] args) {
        int[] arrays = new int[6];
        int i=1;
        int random;
        random = (int)(Math.random()*30)+1;
        arrays[0] = random;
        while ((i++)<5){
            random = (int)(Math.random()*30)+1;
            for (int j = 0; j < i; j++) {
                if (arrays[j]==random){
                    random = (int)(Math.random()*30)+1;
                    j=0;
                }
            }
            arrays[i] = random;
        }
      System.out.println(Arrays.toString(arrays));
    }
}

第二题

思路解析：
给定一个数n，生成n*n的二维数组，然后按照顺时针的方式存入数据。
我们要考虑存入数据时每行的数据是无规律的，所以存入数据时，不能按照行列遍历的时候存放。
按照回文的方式存入，那么可不可以按照数字顺序存放，即现存第一行，然后存放最后一列，接着最后一行，依次类推。

代码实现：

package com.ArraysDome;

/**
 * @Author Zhao
 * @Date 2021/4/25 21:35
 * @Version 1.0
 */
public class AlgorithmDome3 {
    /**
     * 要求：给出一个int整数n，输出n行n列的回文数组
     *
     * @param args
     */
    public static void main(String[] args) {
        int n = 5;
        int[][] arrays = new int[n][n];
        int c = 0;//控制总循环次数
        int rowx = 0;//行控制
        int rowy = 0;//列控制
        int number = 0;//存入数据控制
        int n1 = n;//单次循环控制条件
        while (c < n) {
        	//从左向右
            for (; rowy < n1; rowy++) {
                arrays[rowx][rowy] = ++number;
            }
            //rowy自减是因为上一个for循环结束后rowy会超出索引
            rowy--;
			//从上向下
            for (rowx = c + 1; rowx < n1; rowx++) {
                arrays[rowx][rowy] = ++number;
            }
            //rowx自减与上一个rowy原理相同
            rowx--;
            //这里rowy减一是因为，最后一列已经存储完成
            rowy -= 1;
            //因为最后一列存储完成，所以循环次数要减少
            n1--;
			//从右向左
            for (; rowy > c; rowy--) {
                arrays[rowx][rowy] = ++number;
            }
            //从下向上
            for (; rowx > c; rowx--) {
                arrays[rowx][rowy] = ++number;
            }
            c = c + 1;//执行一次后c+1
            //从新定义rowx\rowy的初始值，从第二行第二列开始
            rowx = c;
            rowy = c;

        }
        //遍历二维数组
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

示例代码2：

以下代码：为尚硅谷代码实现

示例代码一

class RectangleTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个数字");
		int len = scanner.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) {
				if (j < len && arr[i][j] == 0) {
					arr[i][j++] = m;
				} else {
					k = 2;
					i++;
					j--;
					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();
		}
	}
}

示例代码二

class RectangleTest1 {

	public static void main(String[] args) {
		int n = 7;
		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();
		}
	}
}