Java教程

Java:稀疏数组

本文主要是介绍Java:稀疏数组,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1、 当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存数组。

2、 稀疏数组的处理方式是:

  a)      记录数组一共有几行几列,有多少个不同值

  b)      把具有不同值元素的行、列及值记录在一个小规模的数组中,从而缩小程序的规模

3、 如下图

  [0][0]代表原数组有6行,[0][1]代表原数组有6列,[0][2]代表有2个不同值

  [1][0]代表原数组第1行,[1][1]代表原数组第2列,[1][2]代表值为1

  [2][0]代表原数组第2行,[2][1]代表原数组第1列,[2][2]代表值为2

   

 

代码演示1:

 1 package com.jiemyx.array;
 2 
 3 public class ArrayDemo10 {
 4     public static void main(String[] args) {
 5         //1、创建一个原始的二维数组6*6  0代表没有棋子,1代表白棋,2代表黑棋
 6         int[][] array1 = new int[6][6];
 7         array1[1][2] = 1;
 8         array1[2][1] = 2;
 9 
10         //输出原始的数组
11         System.out.println("输出原始的数组");
12         for (int[] ints : array1) {
13             for (int anInt : ints) {
14                 System.out.print(anInt+"\t");
15             }
16             System.out.println();
17         }
18 
19         System.out.println("============");
20 
21         //2、转换为稀疏数组
22         //获取有效值的个数
23         int sum = 0;
24         for (int i = 0; i < array1.length; i++) {
25             for (int j = 0; j < array1[i].length; j++) {
26                 if (array1[i][j] != 0){
27                     sum++;
28                 }
29             }
30         }
31         System.out.println("有效值的个数:"+sum);
32 
33         //创建一个稀疏数组
34         int[][] array2 = new int[sum+1][3];
35         array2[0][0] = 6;
36         array2[0][1] = 6;
37         array2[0][2] = sum;
38 
39         //遍历原始的数组,将非0的值存放稀疏数组中
40         int count = 0;
41         for (int i = 0; i < array1.length; i++) {
42             for (int j = 0; j < array1[i].length; j++) {
43                 if (array1[i][j] != 0){
44                     count++;
45                     array2[count][0] = i;
46                     array2[count][1] = j;
47                     array2[count][2] = array1[i][j];
48                 }
49             }
50         }
51 
52         //输出稀疏数组
53         System.out.println("输出稀疏数组");
54 
55         for (int i = 0; i < array2.length; i++) {
56             System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]);
57         }
58 
59         System.out.println("==========");
60 
61         //3、还原数组
62         //读取稀疏数组
63         int[][] array3 = new int[array2[0][0]][array2[0][1]];
64 
65         //给其中的元素还原它的值
66         for (int i = 1; i < array2.length; i++) {
67             array3[array2[i][0]][array2[i][1]] = array2[i][2];
68         }
69 
70         //打印还原数组
71         System.out.println("输出还原的数组");
72         for (int[] ints : array3) {
73             for (int anInt : ints) {
74                 System.out.print(anInt+"\t");
75             }
76             System.out.println();
77         }
78     }
79 }

运行结果:

输出原始的数组

0     0     0     0     0     0    

0     0     1     0     0     0    

0     2     0     0     0     0    

0     0     0     0     0     0    

0     0     0     0     0     0    

0     0     0     0     0     0    

============

有效值的个数:2

输出稀疏数组

6     6     2

1     2     1

2     1     2

==========

输出还原的数组

0     0     0     0     0     0    

0     0     1     0     0     0    

0     2     0     0     0     0    

0     0     0     0     0     0    

0     0     0     0     0     0    

0     0     0     0     0     0

 

 

代码演示2:

 1 package com.jiemyx.array;
 2 
 3 public class ArrayDemo11 {
 4     public static void main(String[] args) {
 5         //1、创建一个原始的二维数组6*6  0代表没有棋子,1代表白棋,2代表黑棋
 6         int[][] array1 = {{1,2,3},{5,6},{2,4,6,8}};
 7         /*array1[4][2] = 1;
 8         array1[5][1] = 2;
 9         array1[6][3] = 3;*/
10 
11         //输出原始的数组
12         System.out.println("输出原始的数组");
13         for (int[] ints : array1) {
14             for (int anInt : ints) {
15                 System.out.print(anInt+"\t");
16             }
17             System.out.println();
18         }
19 
20         System.out.println("============");
21 
22         //2、转换为稀疏数组
23         //获取有效值的个数
24         int sum = 0;
25         for (int i = 0; i < array1.length; i++) {
26             for (int j = 0; j < array1[i].length; j++) {
27                 if (array1[i][j] != 0){
28                     sum++;
29                 }
30             }
31         }
32         System.out.println("有效值的个数:"+sum);
33 
34         //创建一个稀疏数组
35         int[][] array2 = new int[sum+1][3];
36         array2[0][0] = array1.length;
37 
38         //找到二维元素下有最多元素的一维数组
39         int a = array1[0].length;
40         for (int i = 1; i < array1.length; i++) {
41             if (a < array1[i].length){
42                 a = array1[i].length;
43             }
44             array2[0][1] = a;
45         }
46         array2[0][2] = sum;
47 
48         //遍历原始的数组,将非0的值存放稀疏数组中
49         int count = 0;
50         for (int i = 0; i < array1.length; i++) {
51             for (int j = 0; j < array1[i].length; j++) {
52                 if (array1[i][j] != 0){
53                     count++;
54                     array2[count][0] = i;
55                     array2[count][1] = j;
56                     array2[count][2] = array1[i][j];
57                 }
58             }
59         }
60 
61         //输出稀疏数组
62         System.out.println("输出稀疏数组");
63 
64         for (int i = 0; i < array2.length; i++) {
65             System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]);
66         }
67 
68         System.out.println("==========");
69 
70         //3、还原数组
71         //读取稀疏数组
72         int[][] array3 = new int[array2[0][0]][array2[0][1]];
73 
74         //给其中的元素还原它的值
75         for (int i = 1; i < array2.length; i++) {
76             array3[array2[i][0]][array2[i][1]] = array2[i][2];
77         }
78 
79         //打印还原数组
80         System.out.println("输出还原的数组");
81         for (int[] ints : array3) {
82             for (int anInt : ints) {
83                 System.out.print(anInt+"\t");
84             }
85             System.out.println();
86         }
87     }
88 }

输出原始的数组

1     2     3    

5     6    

2     4     6     8    

============

有效值的个数:9

输出稀疏数组

3     4     9

0     0     1

0     1     2

0     2     3

1     0     5

1     1     6

2     0     2

2     1     4

2     2     6

2     3     8

==========

输出还原的数组

1     2     3     0    

5     6     0     0    

2     4     6     8


 

这篇关于Java:稀疏数组的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!