1.稀疏数组之scala

编写一个五子棋程序，有退出和续上盘的功能

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

基本介绍

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

稀疏数组的处理方法是:

1. 记录数组一共有几行几列，有多少个不同的值(有效值的个数)
2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
   稀疏数组举例说明：

实例分析

1. 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
2. 把稀疏数组存盘，并且可以重新恢复原来的二维数组数
3. 整体思路分析

4) 代码实现

def main(args:Array[String]):Unit={
//先使用二维数组，映射棋
val rows = 11
val cols = 11
val chessMap1 = Array.ofDim[Int](rows, cols)

//初始化
chessMap1(1)(2) = 1 //表示黑子
chessMap1(2)(3) = 2 //表示蓝子

chessMap1(3)(5) = 1 //表示黑子
chessMap1(6)(8) = 2 //表示蓝子

println("原始的棋盘")
for (row <- chessMap1) {
  for (item <- row) {
    printf("%d ", item)
  }
  //换行
  println()
}

//对原始的二维数组进行压缩
//思路
//1. 创建一个ArrayBuffer , 可以动态的添加数据
//2. 使用Node 对象，表示一行数据

val sparseArray = ArrayBuffer[Node]()
//先将第一行数据放入
sparseArray.append(new Node(rows, cols, 0))
//遍历chessMap1 ,如果发现有非0的值，就创建一个Node对象，并加入到sparseArray
for (i <- 0 until chessMap1.length) {
  for (j <- 0 until chessMap1(i).length) {
    if (chessMap1(i)(j) != 0) { //有效数据，需要保存
      sparseArray.append(new Node(i, j, chessMap1(i)(j)))
    }
  }
}

println("稀疏数组情况是")
for(i<- 0 until sparseArray.length) {
  val node = sparseArray(i)
  printf("%d %d %d\n", node.row, node.col, node.value)
}

//将稀疏数组恢复成原始的棋盘
//思路
//1. 读取稀疏数组的第一行，创建一个二维棋盘chessMap2
//2. 遍历（从稀疏数组的第二行）， 每读取到一个Node ,就将对应的值，恢复到chessMap2

val node = sparseArray(0)
val chessMap2 = Array.ofDim[Int](node.row,node.col)
for(i <- 1 until sparseArray.length) {
  val node1 = sparseArray(i)
  chessMap2(node1.row)(node1.col) = node1.value
}

println("恢复后的棋盘是")
for (row <- chessMap2) {
  for (item <- row) {
    printf("%d ", item)
  }
  //换行
  println()
}
}
}
class Node(val row:Int,val col:Int,val value:Int){}