Running Lamp

最新推荐文章于 2023-02-06 17:15:16 发布

Bare_Man

最新推荐文章于 2023-02-06 17:15:16 发布

阅读量388

点赞数

文章标签：数据结构 java

本文链接：https://blog.csdn.net/Bare_Man/article/details/108744805

版权

数据结构之数组–Running Lamp问题
移动一维数组：要求每次移动3个数据，直到数组恢复原状
代码实现：

public static void main(String[] args) {
	int[] Origin = new int[19];
	int[] Run = new int[19];
	int index = 1;
	for(int i=0;i<Origin.length;i++) {
		Origin[i] = index;
		index++;
	}
	for(int i=0;i<Run.length;i++) {
		Run[i] = Origin[i];
	}
	//为了使Run数组进入下面的while循环，先在外面进行一次移动
	int n=3;
	int[] temp = new int[n];//temp数组保存每次移动后被覆盖的数
	for(int i=0;i<n;i++) {
		temp[i] = Run[Run.length-(i+1)];
	}
	int j=Run.length-n-1;
	//将数组进行移动
	for(int i=Run.length-1;i>2;i--) {
		Run[i] = Run[j];
		j--;
	}
	//将被覆盖的数放在数组空出来的位置
	for(int i=0;i<n;i++) {
		Run[i] = temp[n-(i+1)];
	}
	for(int i=0;i<Run.length;i++) {
		System.out.printf("%d ",Run[i]);
	}
	System.out.print("\n");
	//开始Run数组的移动，每次移动都进行输出，直到回到原来的数组
	while(Arrays.equals(Origin,Run)==false) {
		for(int i=0;i<n;i++) {
			temp[i] = Run[Run.length-(i+1)];
		}
		int k=Run.length-n-1;
		for(int i=Run.length-1;i>2;i--) {
			Run[i] = Run[k];
			k--;
		}
		for(int i=0;i<n;i++) {
			Run[i] = temp[n-(i+1)];
		}
		for(int i=0;i<Run.length;i++) {
			System.out.printf("%d ",Run[i]);
		}
		System.out.print("\n");
	}
}
输出结果：
17 18 19 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
14 15 16 17 18 19 1 2 3 4 5 6 7 8 9 10 11 12 13 
11 12 13 14 15 16 17 18 19 1 2 3 4 5 6 7 8 9 10 
8 9 10 11 12 13 14 15 16 17 18 19 1 2 3 4 5 6 7 
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 1 2 3 4 
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 1 
18 19 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 
15 16 17 18 19 1 2 3 4 5 6 7 8 9 10 11 12 13 14 
12 13 14 15 16 17 18 19 1 2 3 4 5 6 7 8 9 10 11 
9 10 11 12 13 14 15 16 17 18 19 1 2 3 4 5 6 7 8 
6 7 8 9 10 11 12 13 14 15 16 17 18 19 1 2 3 4 5 
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 1 2 
19 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 
16 17 18 19 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
13 14 15 16 17 18 19 1 2 3 4 5 6 7 8 9 10 11 12 
10 11 12 13 14 15 16 17 18 19 1 2 3 4 5 6 7 8 9 
7 8 9 10 11 12 13 14 15 16 17 18 19 1 2 3 4 5 6 
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 1 2 3 
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

移动二维数组：要求先移动最外层的数据，然后移动第二层的数据，然后移动最里层的数据，直到恢复原状
移动二维数组与移动一维数组的思想大致相同，只不过多了一步将二维数组拆分为一维数组的过程
代码实现：

	public static void main(String[] args) {
	int[][] arr = new int[6][6];
	int index = 1;
	for(int j=0;j<6;j++) {
		for(int i=0;i<6;i++) {
			arr[i][j] = index;
			index++;
		}
	}
	//将第三层的数据用一个一维数组保存起来
	int[] layer3 = new int[20];
	for(int i=0;i<6;i++) {
		layer3[i] = arr[i][0];
	}
	int j1=1;
	for(int i=6;i<11;i++) {
		layer3[i] = arr[5][j1];
		j1++;
	}
	int i1=4;
	for(int i=11;i<16;i++) {
		layer3[i] = arr[i1][5];
		i1--;
	}
	int j2=4;
	for(int i=16;i<20;i++) {
		layer3[i] = arr[0][j2];
		j2--;
	}
	//将第二层的数据用一个一维数组保存起来
	int[] layer2 = new int[12];
	int i2=1;
	for(int i=0;i<4;i++) {
		layer2[i] = arr[i2][1];
		i2++;
	}
	int j3=2;
	for(int i=4;i<7;i++) {
		layer2[i] = arr[4][j3];
		j3++;
	}
	int i3=4;
	for(int i=7;i<10;i++) {
		layer2[i] = arr[i3][4];
		i3--;
	}
	int j4=3;
	for(int i=10;i<12;i++) {
		layer2[i] = arr[1][j4];
		j4--;
	}
	//将第一层的数据用一个一维数组保存起来
	int[] layer1 = new int[4];
	int i4=2;
	for(int i=0;i<2;i++) {
		layer1[i] = arr[i4][2];
		i4++;
	}
	int i5=3;
	for(int i=2;i<4;i++) {
		layer1[i] = arr[i5][3];
		i5--;
	}
	//创建一个变化的数组
	int[][] arrrun = new int[6][6];
	for(int j=0;j<6;j++) {
		for(int i=0;i<6;i++) {
			arrrun[i][j] = arr[i][j];
		}
	}
	//复制layer3以作比较
	int[] layer3copy = new int[20];
	for(int i=0;i<20;i++) {
		layer3copy[i] = layer3[i];
	}
	//先进行一次移动，以进入后面的while语句
	move(layer3);
	for(int i=0;i<6;i++) {
		arrrun[i][0] = layer3[i];
	}
	j1=1;
	for(int i=6;i<11;i++) {
		arrrun[5][j1] = layer3[i];
		j1++;
	}
	i1=4;
	for(int i=11;i<16;i++) {
		arrrun[i1][5] = layer3[i];
		i1--;
	}
	j2=4;
	for(int i=16;i<20;i++) {
		arrrun[0][j2] = layer3[i];
		j2--;
	}
	for(int j=0;j<6;j++) {
		for(int i=0;i<6;i++) {
			if(i==5) {
				System.out.printf("%d ",arrrun[i][j]);
				System.out.printf("\n");
			}
			else {
				System.out.printf("%d ",arrrun[i][j]);
			}
		}
	}
	while(Arrays.equals(layer3,layer3copy) == false) {
		move(layer3);
		for(int i=0;i<6;i++) {
			arrrun[i][0] = layer3[i];
		}
		j1=1;
		for(int i=6;i<11;i++) {
			arrrun[5][j1] = layer3[i];
			j1++;
		}
		i1=4;
		for(int i=11;i<16;i++) {
			arrrun[i1][5] = layer3[i];
			i1--;
		}
		j2=4;
		for(int i=16;i<20;i++) {
			arrrun[0][j2] = layer3[i];
			j2--;
		}
		for(int j=0;j<6;j++) {
			for(int i=0;i<6;i++) {
				if(i==5) {
					System.out.printf("%d ",arrrun[i][j]);
					System.out.print("\n");
				}
				else {
					System.out.printf("%d ",arrrun[i][j]);
				}
			}
		}
	}
	System.out.println("第三层移动完毕");
	//第二层和第一层的做法同第三层
	int[] layer2copy = new int[12];
	for(int i=0;i<12;i++) {
		layer2copy[i] = layer2[i];
	}
	move(layer2);
	i2=1;
	for(int i=0;i<4;i++) {
		arrrun[i2][1] = layer2[i];
		i2++;
	}
	j3=2;
	for(int i=4;i<7;i++) {
		arrrun[4][j3] = layer2[i];
		j3++;
	}
	i3=4;
	for(int i=7;i<10;i++) {
		arrrun[i3][4] = layer2[i];
		i3--;
	}
	j4=3;
	for(int i=10;i<12;i++) {
		arrrun[1][j4] = layer2[i];
		j4--;
	}
	for(int j=0;j<6;j++) {
		for(int i=0;i<6;i++) {
			if(i==5) {
				System.out.printf("%d ",arrrun[i][j]);
				System.out.print("\n");
			}
			else {
				System.out.printf("%d ",arrrun[i][j]);
			}
		}
	}
	while(Arrays.equals(layer2,layer2copy) == false) {
		move(layer2);
		i2=1;
		for(int i=0;i<4;i++) {
			arrrun[i2][1] = layer2[i];
			i2++;
		}
		j3=2;
		for(int i=4;i<7;i++) {
			arrrun[4][j3] = layer2[i];
			j3++;
		}
		i3=4;
		for(int i=7;i<10;i++) {
			arrrun[i3][4] = layer2[i];
			i3--;
		}
		j4=3;
		for(int i=10;i<12;i++) {
			arrrun[1][j4] = layer2[i];
			j4--;
		}
		for(int j=0;j<6;j++) {
			for(int i=0;i<6;i++) {
				if(i==5) {
					System.out.printf("%d ",arrrun[i][j]);
					System.out.print("\n");
				}
				else {
					System.out.printf("%d ",arrrun[i][j]);
				}
			}
		}
	}
	System.out.println("第二层移动完毕");
	int[] layer1copy = new int[4];
	for(int i=0;i<4;i++) {
		layer1copy[i] = layer1[i];
	}
	move(layer1);
	i4=2;
	for(int i=0;i<2;i++) {
		arrrun[i4][2] = layer1[i];
		i4++;
	}
	i5=3;
	for(int i=2;i<4;i++) {
		arrrun[i5][3] = layer1[i];
		i5--;
	}
	for(int j=0;j<6;j++) {
		for(int i=0;i<6;i++) {
			if(i==5) {
				System.out.printf("%d ",arrrun[i][j]);
				System.out.print("\n");
			}
			else {
				System.out.printf("%d ",arrrun[i][j]);
			}
		}
	}
	while(Arrays.equals(layer1,layer1copy) == false) {
		move(layer1);
		i4=2;
		for(int i=0;i<2;i++) {
			arrrun[i4][2] = layer1[i];
			i4++;
		}
		i5=3;
		for(int i=2;i<4;i++) {
			arrrun[i5][3] = layer1[i];
			i5--;
		}
		for(int j=0;j<6;j++) {
			for(int i=0;i<6;i++) {
				if(i==5) {
					System.out.printf("%d ",arrrun[i][j]);
					System.out.print("\n");
				}
				else {
					System.out.printf("%d ",arrrun[i][j]);
				}
			}
		}
	}
	System.out.println("第一层移动完毕");
}
public static void move(int layer[]) {
	int n=1;
	int[] temp = new int[n];//temp数组保存每次移动后被覆盖的数
	for(int i=0;i<n;i++) {
		temp[i] = layer[layer.length-(i+1)];
	}
	int j=layer.length-n-1;
	//将数组进行移动
	for(int i=layer.length-1;i>(n-1);i--) {
		layer[i] = layer[j];
		j--;
	}
	//将被覆盖的数放在数组空出来的位置
	for(int i=0;i<n;i++) {
		layer[i] = temp[n-(i+1)];
	}
}
输出结果：
7 1 2 3 4 5 
13 8 9 10 11 6 
19 14 15 16 17 12 
25 20 21 22 23 18 
31 26 27 28 29 24 
32 33 34 35 36 30 
13 7 1 2 3 4 
19 8 9 10 11 5 
25 14 15 16 17 6 
31 20 21 22 23 12 
32 26 27 28 29 18 
33 34 35 36 30 24 
19 13 7 1 2 3 
25 8 9 10 11 4 
31 14 15 16 17 5 
32 20 21 22 23 6 
33 26 27 28 29 12 
34 35 36 30 24 18 
25 19 13 7 1 2 
31 8 9 10 11 3 
32 14 15 16 17 4 
33 20 21 22 23 5 
34 26 27 28 29 6 
35 36 30 24 18 12 
31 25 19 13 7 1 
32 8 9 10 11 2 
33 14 15 16 17 3 
34 20 21 22 23 4 
35 26 27 28 29 5 
36 30 24 18 12 6 
32 31 25 19 13 7 
33 8 9 10 11 1 
34 14 15 16 17 2 
35 20 21 22 23 3 
36 26 27 28 29 4 
30 24 18 12 6 5 
33 32 31 25 19 13 
34 8 9 10 11 7 
35 14 15 16 17 1 
36 20 21 22 23 2 
30 26 27 28 29 3 
24 18 12 6 5 4 
34 33 32 31 25 19 
35 8 9 10 11 13 
36 14 15 16 17 7 
30 20 21 22 23 1 
24 26 27 28 29 2 
18 12 6 5 4 3 
35 34 33 32 31 25 
36 8 9 10 11 19 
30 14 15 16 17 13 
24 20 21 22 23 7 
18 26 27 28 29 1 
12 6 5 4 3 2 
36 35 34 33 32 31 
30 8 9 10 11 25 
24 14 15 16 17 19 
18 20 21 22 23 13 
12 26 27 28 29 7 
6 5 4 3 2 1 
30 36 35 34 33 32 
24 8 9 10 11 31 
18 14 15 16 17 25 
12 20 21 22 23 19 
6 26 27 28 29 13 
5 4 3 2 1 7 
24 30 36 35 34 33 
18 8 9 10 11 32 
12 14 15 16 17 31 
6 20 21 22 23 25 
5 26 27 28 29 19 
4 3 2 1 7 13 
18 24 30 36 35 34 
12 8 9 10 11 33 
6 14 15 16 17 32 
5 20 21 22 23 31 
4 26 27 28 29 25 
3 2 1 7 13 19 
12 18 24 30 36 35 
6 8 9 10 11 34 
5 14 15 16 17 33 
4 20 21 22 23 32 
3 26 27 28 29 31 
2 1 7 13 19 25 
6 12 18 24 30 36 
5 8 9 10 11 35 
4 14 15 16 17 34 
3 20 21 22 23 33 
2 26 27 28 29 32 
1 7 13 19 25 31 
5 6 12 18 24 30 
4 8 9 10 11 36 
3 14 15 16 17 35 
2 20 21 22 23 34 
1 26 27 28 29 33 
7 13 19 25 31 32 
4 5 6 12 18 24 
3 8 9 10 11 30 
2 14 15 16 17 36 
1 20 21 22 23 35 
7 26 27 28 29 34 
13 19 25 31 32 33 
3 4 5 6 12 18 
2 8 9 10 11 24 
1 14 15 16 17 30 
7 20 21 22 23 36 
13 26 27 28 29 35 
19 25 31 32 33 34 
2 3 4 5 6 12 
1 8 9 10 11 18 
7 14 15 16 17 24 
13 20 21 22 23 30 
19 26 27 28 29 36 
25 31 32 33 34 35 
1 2 3 4 5 6 
7 8 9 10 11 12 
13 14 15 16 17 18 
19 20 21 22 23 24 
25 26 27 28 29 30 
31 32 33 34 35 36 
第三层移动完毕
1 2 3 4 5 6 
7 14 8 9 10 12 
13 20 15 16 11 18 
19 27 21 22 17 24 
25 26 28 29 29 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 20 14 8 9 12 
13 27 15 16 10 18 
19 28 21 22 11 24 
25 26 29 29 23 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 27 20 14 8 12 
13 28 15 16 9 18 
19 29 21 22 10 24 
25 26 29 23 17 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 28 27 20 14 12 
13 29 15 16 8 18 
19 29 21 22 9 24 
25 26 23 17 11 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 29 28 27 20 12 
13 29 15 16 14 18 
19 23 21 22 8 24 
25 26 17 11 10 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 29 29 28 27 12 
13 23 15 16 20 18 
19 17 21 22 14 24 
25 26 11 10 9 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 23 29 29 28 12 
13 17 15 16 27 18 
19 11 21 22 20 24 
25 26 10 9 8 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 17 23 29 29 12 
13 11 15 16 28 18 
19 10 21 22 27 24 
25 26 9 8 14 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 11 17 23 29 12 
13 10 15 16 29 18 
19 9 21 22 28 24 
25 26 8 14 20 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 10 11 17 23 12 
13 9 15 16 29 18 
19 8 21 22 29 24 
25 26 14 20 27 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 9 10 11 17 12 
13 8 15 16 23 18 
19 14 21 22 29 24 
25 26 20 27 28 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 8 9 10 11 12 
13 14 15 16 17 18 
19 20 21 22 23 24 
25 26 27 28 29 30 
31 32 33 34 35 36 
第二层移动完毕
1 2 3 4 5 6 
7 8 9 10 11 12 
13 14 21 15 17 18 
19 20 22 16 23 24 
25 26 27 28 29 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 8 9 10 11 12 
13 14 22 21 17 18 
19 20 16 15 23 24 
25 26 27 28 29 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 8 9 10 11 12 
13 14 16 22 17 18 
19 20 15 21 23 24 
25 26 27 28 29 30 
31 32 33 34 35 36 
1 2 3 4 5 6 
7 8 9 10 11 12 
13 14 15 16 17 18 
19 20 21 22 23 24 
25 26 27 28 29 30 
31 32 33 34 35 36 
第一层移动完毕

由此可以想象到移动三层数组的情况：先拆分为二维数组，才拆分为一维数组进行移动。原理大致相同，但每增加一维，代码量都成几何倍数增长，所以很麻烦。（其实是我懒）

此次记录到此结束。

Bare_Man

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Running Lamp

数据结构之数组–Running Lamp问题移动一维数组：要求每次移动3个数据，直到数组恢复原状代码实现：public static void main(String[] args) { int[] Origin = new int[19]; int[] Run = new int[19]; int index = 1; for(int i=0;i<Origin.length;i++) { Origin[i] = index; index++; } for(int i=0;i
复制链接

扫一扫