稀疏数组 

  1 public class  SparseArray{
  2     public static void main(String[] args) {
  3         // 一、二维数组 --> 稀疏数组
  4         // 1.创建一个二维数组 size：11 * 11
  5         // 0 表示棋盘    1 表示黑子    2 表示蓝子
  6 
  7         int[][] chessArr1 = new int[11][11];
  8         chessArr1[1][2] = 1;
  9         chessArr1[2][3] = 2;
 10         
 11         System.out.println("输出原始二维数组为***************");
 12         
 13         for(int i = 0; i < chessArr1.length; i++){
 14             System.out.println();
 15             for(int j = 0; j < chessArr1[i].length; j++){
 16                 System.out.printf("%d\t",chessArr1[i][j]);
 17             }
 18             System.out.printf("\n\n");
 19         }
 20 
 21         // 2.遍历二维数组，得到非零数据元素的个数(sum)
 22         int sum = 0; 

 32         for(int[] row: chessArr1){
 33             for(int data: row){
 34                 if(0 != data){
 35                     sum++;
 36                 }
 37             }
 38         }
 39         System.out.println("输出原始二维数组非零数据元素的个数sum=" + sum); // sum = 2
 40 
 41 
 42         // 3.创建存储原始二维数组的稀疏数组
 43         /*
 44             并用 row col value，分别来存储原始二维数组的行、列、非零数据元素的个数
 45             作为稀疏数组的第 0 行
 46             row col value
 47             11    11      2
 48 
 49 
 50             这里的理解：有n个非零数据元素，稀疏数组的行数就为 n + 1 ,列数为3.
 51             即：稀疏数组中的每一行只存储一个非零数据元素
 52         */
 53         // 3.1 创建size：(sum + 1) * 3 的稀疏数组
 54         int[][] sparseArr = new int[sum + 1][3];
 55         
 56         // 3.2 用第 0 行存储原始二维数组的行、列、非零数据元素的个数
 57         sparseArr[0][0] = 11; // 存储原始二维数组的行数 row
 58         sparseArr[0][1] = 11; // 存储原始二维数组的行数 col
 59         sparseArr[0][2] = sum; // 存储原始二维数组的非零数据元素的个数 sum
 60 
 61         // 3.3 存储原始二维数组的非零数据元素(从稀疏数组的第 1 行开始赋值)
 62         int count = 1; // 用于记录原始二维数组的非零数据元素的个数
 63         for(int i = 0; i < chessArr1.length; i++){
 64             for(int j = 0; j < chessArr1[i].length; j++){
 65                 if(0 != chessArr1[i][j]){
 66                     
 67                     sparseArr[count][0] = i; // 存储原始二维数组某个元素的初始(所在)行 
 68                     sparseArr[count][1] = j; // 存储原始二维数组某个元素的初始(所在)列
 69                     sparseArr[count][2] = chessArr1[i][j]; // 存储原始二维数组某个元素的(具体)值
 70                     
 71                     count++;
 72 
 73                 }
 74             }
 75         }
 76 
 77         System.out.println("得到的稀疏数组为***************");
 78         // 3.4 输出(检验)一下稀疏数组所存储的内容是否正确
 79         for(int[] row: sparseArr){
 80             System.out.println();
 81             for(int data: row){
 82                 System.out.printf("%d\t",data);
 83             }
 84             System.out.println();
 85         }
 86 
 87 
 88 
 89         // 稀疏数组 --> 二维数组
 90 
 91         // 1. 由稀疏数组的第 0 行存储的内容，创建一个 size: sparseArr[0][0] * sparseArr[0][1]的
 92         // 二维数组
 93 
 94         int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
 95 
 96         // 2. 将稀疏数组中所存储的原始二维数组元素赋值给新的二维数组
 97         // 这里从稀疏数组的第 1 行开始，因为起初创建稀疏数组时，也是从第 1 行开始存储元素的
 98         for(int i = 1; i < sum + 1; i++){
 99             // 这里还原时，要清楚原始二维数组元素的所在行、列
100             // 从稀疏数组的第 1 行开始，每一行只存储一个非零数据元素！！！
101             /*
102                 sparseArr[i][0] = row;
103                 sparseArr[i][1] = col;
104                 sparseArr[i][2] = value;
105                 
106             */
107             chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
108         }
109 
110         System.out.println("输出还原后的二维数组为***********************");
111         // 3. 输出还原后的二维数组
112         for(int[] chessArrData: chessArr2){
113             System.out.println();
114             for(int dataArr2: chessArrData){
115                 System.out.printf("%d\t",dataArr2);
116             }
117             System.out.println();
118         }
119 
120 
121     }
122 }

/*


小结：


一、稀疏数组 --> 二维数组

1. 创建一个二维数组
2. 遍历原始二维数组，记录其中非零数据元素的个数 sum
3. 依据非零个数 sum 创建 size：(sum + 1) * 3 的稀疏数组


①稀疏数组的第 0 行 用来存储原始二维数组的 行数、列数、非零数据元素的个数

row 　　 col 　　 value

11 　　   11 　　 sum = 2


②从稀疏数组的第 1 行开始存储原始二维数组的非零元素
从稀疏数组中第一行开始：每一行只存储一个非零元素
int count = 1; // 记录非零元素的个数
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = chessArr1[i][j];

 


二、二维数组 --> 稀疏数组

1. 依据稀疏数组第 0 行存储的内容，创建一个size: sparseArr[0][0] * sparseArr[0][1]的二维数组

int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];

2. 从稀疏数组的第 1 行开始，将所存储的原始二维数组数据元素赋值给新创建的二维数组

for(int i = 1; i < sum + 1; i++){
// 注意：i 是从 1 ~ sum + 1 (sum + 1 为稀疏数组创建时的总行数)
chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
*/

 

 

 

posted @ 2019-07-29 14:41  hellozwx  阅读(175)  评论(0)  编辑  收藏  举报