JAVA算法-稀疏数组(sparse array)

稀疏数组(sparse array):

  实际需求：

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

   分析问题:

       因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据  -->  稀疏数组。

 基本介绍:

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

稀疏数组的处理方法是：

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

应用实列：

1. 使用稀疏数组，来保留类似前面的二维数组（棋盘，地图等等）。

2. 把稀疏数组存盘，并且可以从新恢复原来的二维数组。

3. 整体思路分析。

代码实现(scala):

package com.jerryD.SparseArray

import java.io.{BufferedReader, BufferedWriter, File, FileReader, FileWriter, PrintWriter}

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

/*
    稀疏数组
 */
object SparseArr {

  def main(args: Array[String]): Unit = {

    val filePath = "D:\\code\\github\\algorithm\\src\\main\\scala\\com\\jerryD\\SparseArray\\sparseArry.txt"
    val rowSize = 11
    val colSize = 11
    // 演示一个稀疏数组的使用
    val chessMap = Array.ofDim[Int](rowSize, colSize)
    // 初始化地图
    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)
    //    save ArrayBuffer
    val sparseArr = ArrayBuffer[Node]()
    // 记录棋盘大小
    val node = new Node(rowSize, colSize, 0)
    sparseArr.append(node)
    for (i <- 0 until chessMap.length; j <- 0 until chessMap(i).length) {
      // 判断该值是否为0， if is 0 not save else save
      if (chessMap(i)(j) != 0) {
        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)
    }

    // 存盘
    val writer = new BufferedWriter(new FileWriter(filePath))
    for (node <- sparseArr) {
      writer.write(node.row + "\t" + node.col + "\t" + node.value)
      writer.newLine()
      writer.flush()
    }
    writer.close()

    // 读盘
    val source = Source.fromFile(filePath, "UTF-8")
    val it = source.getLines()
    val date = ArrayBuffer[Node]()
    it.foreach(line => {
      val strArr = line.split("\t")
      if(strArr.length == 3) date.append(new Node(strArr(0).toInt, strArr(1).toInt, strArr(2).toInt))
    })

    source.close()
    // 稀疏数组 -> 原始数组
    // 读取稀疏数组的第一个节点
    val newNode = date(0)
    val newRowSize = newNode.row
    val newColSize = node.col
    val newChessMap = Array.ofDim[Int](rowSize, colSize)

    for (i <- 1 until date.length) {
      val node = date(i)
      newChessMap(node.row)(node.col) = node.value
    }

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

github:

  https://github.com/BigData-Dong/algorithm