数据结构和算法_稀疏数组

数据结构：

（1）线性结构：一维数组，队列，链表，栈

（2）非线性结构：二维数组，多维数组，广义表，树，森林，图

 

使用稀疏数组对原始数据压缩

0 0 0 0 0

0 1 0 0 0

2 0 0 0 0

稀疏数组：

row  col  value

总行数=3 总列数=5  有效值个数=2

1     1     1

2     0     2

package chapter02

import scala.collection.mutable.ArrayBuffer

object test01 {

   def main(args:Array[String]):Unit={
     //定义二维数组
     val rows = 3
     val cols = 5

     val chessMap1: Array[Array[Int]] = Array.ofDim[Int](rows,cols)
     chessMap1(1)(1) = 1
     chessMap1(2)(0) = 2


     //遍历二维数组
     for ( i <- 0 until chessMap1.length){
       for ( j <- 0 until chessMap1(i).length){
         printf("%d ",chessMap1(i)(j))
       }
       println()
     }



     //对二维数组压缩
     //创建ArrayBuffer,动态的压缩数据
     //用node对象表示一个数据
     val sparseArray = ArrayBuffer[Node]()
     sparseArray.append(new Node(rows,cols,0))
     //遍历chessMap1，如果发现一个非零的对象，则加入sparseArray
     for ( i <- 0 until chessMap1.length){
       for ( j <- 0 until chessMap1(i).length){
         val result  = chessMap1(i)(j)
         if (result != 0){
           sparseArray.append(new Node(i,j,result))
         }
       }
     }

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

       }

     //将稀疏数组恢复成二维数据
     val col_2 = sparseArray(0).col
     val row_2 = sparseArray(0).row

     val chessMap2 = Array.ofDim[Int](row_2,col_2)

     for (i <- 1 until sparseArray.length){
       val col_res = sparseArray(i).col
       val row_res = sparseArray(i).row
       val value_res = sparseArray(i).value
       chessMap2(row_res)(col_res)=value_res
     }

     println("恢复后的二维数组：")
     for (i <- 0 until chessMap2.length){
       for (j <- 0 until chessMap2(i).length){
         printf("%d ",chessMap2(i)(j))
       }
       println()
     }

     
     }


}

class Node(val row:Int,val col:Int,val value:Int){

}