package main

import "fmt"

type Node struct {
   Row   int
   Col   int
   Value int
}

// 稀疏数组
func main() {

   sparse := ToSparse()

   ToArray(sparse)
}

// ToArray 稀疏数组恢复
func ToArray(sparse []Node)  {

   var arr  [11][11]int

   for k, node := range sparse {
      if k != 0 {
         arr[node.Row][node.Col] = node.Value
      }
   }

   fmt.Println("恢复后的原始数据")
   for _, v := range arr {
      fmt.Println(v)
   }



}

// ToSparse 数组转换为稀疏数组
func ToSparse() []Node {
   const row = 11
   const col = 11

   // 1 创建一个原始数组 1 黑子 2 蓝子
   var chessMap [row][col]int

   chessMap[1][2] = 1
   chessMap[2][3] = 2
   // 2 输出查看原始数据
   for _, v := range chessMap {
      fmt.Println(v)
   }

   // 3 转为稀疏数组
   // 遍历chessMap 发现一个元素的值!=0 创建一个node结构体
   // 将其放入到切片中
   var sparseArr []Node
   // 加入规模 标准的稀疏数组 含有 行数 列数
   node0 := Node{
      Row:   row,
      Col:   col,
      Value: 0,
   }
   sparseArr = append(sparseArr, node0)

   for i, v := range chessMap {
      for j, v2 := range v {
         if v2 != 0 {
            // 创建一个节点
            var node = Node{
               Row:   i,
               Col:   j,
               Value: v2,
            }
            sparseArr = append(sparseArr, node)
         }
      }
   }

   // 4 输出查看原始数据
   for _, node := range sparseArr {
      fmt.Printf("%d %d %d \n",node.Row, node.Col, node.Value)
   }

   return sparseArr