Java编程内功-数据结构与算法「稀疏数组」

开发 后端 算法
当一个数组中大部分元素为0,或者为同一个值的数组时,可以使用稀疏数组来保存该数组,本篇就给大家介绍关于稀疏数组的相关知识。

[[385874]]

 基本介绍

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

稀疏数组的处理方法是:

  1. 记录数组一共有几行几列,有多少个不同的值.
  2. 把具有不同值的元素的行列记录在一个小规模的数组中,从而缩小程序的规模.

举例说明

原始的二维数组


原始的二维数组

转换后的二维数组

第一行记录原始数组有多少行列,多少值(8<<代表原始数组的值的个数22,15,11,17,-6,39,91,28>>)


转换后的二维数组

二维数组转稀疏数组思路

  1. 遍历原始的二维数组,得到有效数据的个数sum
  2. 根据sum就可以创建稀疏数组sparseArr int(sum+1)(3)
  3. 将二维数组的有效数据存入到稀疏数组

稀疏数组转原始二维数组思路

  1. 先读取稀疏数组的第一行,根据第一行的数据,创建原始的二维数组
  2. 再读取稀疏数组后几行的数据,并赋给原始的二维数组即可.

应用实例

  1. 使用稀疏数组,来保留类似前面的二维数组(棋盘\地图)等
  2. 把稀疏数组存盘,并且可重新恢复原来的二维数组数

代码案例

  1. package com.structures.sparsearray; 
  2.  
  3. public class SparseArray { 
  4.  
  5.     public static void main(String[] args) { 
  6.         //创建一个原始的二维数组11*11 
  7.         //0:表示没有棋子,1表示黑子,2表示白子 
  8.         int[][] chessArr1 = new int[11][11]; 
  9.         chessArr1[1][2] = 1; 
  10.         chessArr1[2][3] = 2; 
  11.         //输出原始二维数组 
  12.         System.out.println("原始的二维数组"); 
  13.         for (int[] ints : chessArr1) { 
  14.             for (int anInt : ints) { 
  15.                 System.out.printf("%d\t", anInt); 
  16.             } 
  17.             System.out.println(); 
  18.         } 
  19.         //将二维数组转稀疏数组 
  20.         //1.先遍历二维数组,得到非0数据的个数. 
  21.         int sum = 0; 
  22.         for (int[] ints : chessArr1) { 
  23.             for (int anInt : ints) { 
  24.                 if (anInt != 0) { 
  25.                     sum++; 
  26.                 } 
  27.             } 
  28.         } 
  29.         System.out.println("sum = " + sum); 
  30.         //2.创建对应的稀疏数组 
  31.         int[][] sparseArr = new int[sum + 1][3]; 
  32.         //给稀疏数组赋值 
  33.         sparseArr[0][0] = 11; 
  34.         sparseArr[0][1] = 11; 
  35.         sparseArr[0][2] = sum
  36.         //遍历原始数组,将非0的值存放到稀疏数组中 
  37.         int count = 0;//count用于记录第几个非0数据 
  38.         for (int i = 0; i < chessArr1.length; i++) { 
  39.             for (int j = 0; j < chessArr1[i].length; j++) { 
  40.                 if (chessArr1[i][j] != 0) { 
  41.                     count++; 
  42.                     sparseArr[count][0] = i; 
  43.                     sparseArr[count][1] = j; 
  44.                     sparseArr[count][2] = chessArr1[i][j]; 
  45.                 } 
  46.             } 
  47.         } 
  48.         //输出稀疏数组 
  49.         System.out.println(); 
  50.         System.out.println("得到的稀疏数组为~~~~"); 
  51.         for (int[] ints : sparseArr) { 
  52.             for (int anInt : ints) { 
  53.                 if (anInt != 0) { 
  54.                     System.out.printf("%d\t", anInt); 
  55.                 } 
  56.             } 
  57.             System.out.println(); 
  58.         } 
  59.  
  60.         //将稀疏数组恢复成原始数组 
  61.         int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]]; 
  62.         for (int i = 0; i < sparseArr[0][2]; i++) { 
  63.             chessArr2[sparseArr[i + 1][0]][sparseArr[i + 1][1]] = sparseArr[i + 1][2]; 
  64.         } 
  65.         //恢复后的原始数组 
  66.         System.out.println("恢复后的原始数组"); 
  67.         for (int[] ints : chessArr2) { 
  68.             for (int anInt : ints) { 
  69.                 System.out.printf("%d\t", anInt); 
  70.             } 
  71.             System.out.println(); 
  72.         } 
  73.     } 
  74. /* 
  75. 原始的二维数组 
  76. 0    0    0    0    0    0    0    0    0    0    0 
  77. 0    0    1    0    0    0    0    0    0    0    0 
  78. 0    0    0    2    0    0    0    0    0    0    0 
  79. 0    0    0    0    0    0    0    0    0    0    0 
  80. 0    0    0    0    0    0    0    0    0    0    0 
  81. 0    0    0    0    0    0    0    0    0    0    0 
  82. 0    0    0    0    0    0    0    0    0    0    0 
  83. 0    0    0    0    0    0    0    0    0    0    0 
  84. 0    0    0    0    0    0    0    0    0    0    0 
  85. 0    0    0    0    0    0    0    0    0    0    0 
  86. 0    0    0    0    0    0    0    0    0    0    0 
  87. sum = 2 
  88.  
  89. 得到的稀疏数组为~~~~ 
  90. 11    11    2 
  91. 1    2    1 
  92. 2    3    2 
  93. 恢复后的原始数组 
  94. 0    0    0    0    0    0    0    0    0    0    0 
  95. 0    0    1    0    0    0    0    0    0    0    0 
  96. 0    0    0    2    0    0    0    0    0    0    0 
  97. 0    0    0    0    0    0    0    0    0    0    0 
  98. 0    0    0    0    0    0    0    0    0    0    0 
  99. 0    0    0    0    0    0    0    0    0    0    0 
  100. 0    0    0    0    0    0    0    0    0    0    0 
  101. 0    0    0    0    0    0    0    0    0    0    0 
  102. 0    0    0    0    0    0    0    0    0    0    0 
  103. 0    0    0    0    0    0    0    0    0    0    0 
  104. 0    0    0    0    0    0    0    0    0    0    0 
  105. */ 

 【编辑推荐】

 

责任编辑:姜华 来源: 今日头条
相关推荐

2021-05-12 09:07:09

Java数据结构算法

2021-03-09 06:30:32

JAVA数据结构算法

2021-04-13 09:37:41

Java数据结构算法

2021-03-18 08:44:20

Java数据结构算法

2021-03-23 08:33:22

Java数据结构算法

2021-03-26 08:40:28

Java数据结构算法

2021-03-12 09:13:47

Java数据结构算法

2021-03-10 08:42:19

Java数据结构算法

2021-03-17 09:27:36

Java数据结构算法

2021-04-07 09:26:37

Java数据结构算法

2021-04-16 09:40:52

Java数据结构算法

2021-04-15 09:36:44

Java数据结构算法

2021-04-22 10:07:45

Java数据结构算法

2021-03-14 08:27:40

Java数据结构算法

2021-04-23 09:12:09

Java数据结构算法

2021-03-11 08:53:20

Java数据结构算法

2021-05-13 07:34:56

Java数据结构算法

2021-03-24 10:41:04

Java数据结构算法

2021-05-08 08:28:38

Java数据结构算法

2021-04-27 06:21:29

Java数据结构算法
点赞
收藏

51CTO技术栈公众号