稀疏数组

基本介绍

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

处理方法

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

实际需求

编写的五子棋程序中，有存盘退出和续上盘的功能。

举例说明

应用案例

1. 使用稀疏数组，来保留类似前面的二维数组（棋盘、地图等）
2. 把稀疏数组存盘，并且可以从新恢复原来的二维数组

代码实现

package chapter18

import java.io.{File, PrintWriter}

import scala.collection.mutable.ArrayBuffer
import scala.io.Source

object SparseArr {
  def main(args: Array[String]): Unit = {
    //演示一个稀疏数组的使用
    val chessMap = Array.ofDim[Int](11, 11)
    //初始化地图
    chessMap(1)(2) = 1 //1表示黑子
    chessMap(2)(3) = 2 //2 表示白子
    //输出原始的地图
    for (item <- chessMap) {
      for (item2 <- item) {
        printf("%d\t", item2)
      }
      println()
    }

    //将chessMap转成稀疏数组
    //思路=》 效果是达到对数据的压缩
    //class Node (row, col, value)
    //ArrayBuffer

    val sparseArr = ArrayBuffer[Node]()
    val rowSize = 11
    val colSize = 11
    val node = new Node(rowSize, colSize, 0) // 保存原始数组行列数
    sparseArr.append(node)
    for (i <- 0 until chessMap.length) {
      for (j <- 0 until chessMap(i).length) {
        //判断该值是否为0，不为0就保存
        if (chessMap(i)(j) != 0) {
          //构建一个Node
          val node = new Node(i, j, chessMap(i)(j))
          sparseArr.append(node) //加入到稀疏数组
        }
      }
    }
    println("----------稀疏数组--------------")
    //输出稀疏数组
    for (node <- sparseArr) {
      printf("%d\t%d\t%d\n", node.row, node.col, node.value)
    }

    //存盘
    var pathName = "src/main/DataStructuresAndAlgorithms/chapter18/sparseArr.txt" //文件名
    val writer = new PrintWriter(new File(pathName))
    for (node <- sparseArr) {
      writer.println(node.row + "\t" + node.col + "\t" + node.value)
    }
    writer.close()

    //读盘
    val file1 = Source.fromFile(pathName)
    val lines = file1.getLines()
    //读入到sparseArr2
    val sparseArr2 = ArrayBuffer[Node]()
    println("-------------开始读盘---------------------")
    for (line <- lines) {
      val strings = line.mkString.split("\t")
      sparseArr2.append(new Node(strings(0).toInt, strings(1).toInt, strings(2).toInt))
    }
    file1.close()
    println("-------------完成读盘,读入后的数据如下---------------------")
    for (node <- sparseArr2) {
      println(node.row + "\t" + node.col + "\t" + node.value)
    }

    //稀疏数组-> 原始数组
    //读取稀疏数组的第一个节点
    val newNode = sparseArr2(0)
    val rowSize2 = newNode.row
    val colSize2 = newNode.col
    //创建新的棋盘
    val chessMap2 = Array.ofDim[Int](rowSize2, colSize2)
    //解析数据到棋盘
    for (i <- 1 until sparseArr.length) { //跳过第一个
      val node = sparseArr2(i)
      chessMap2(node.row)(node.col) = node.value
    }

    println("----------------从稀疏数组恢复后的地图-------------")
    for (item <- chessMap2) {
      for (item2 <- item) {
        printf("%d\t", item2)
      }
      println()
    }
  }
}

/**
 * 节点
 *
 * @param row   行编号
 * @param col   列编号
 * @param value 值
 */
class Node(val row: Int, val col: Int, val value: Int)

运行结果