稀疏算法

需求：有11*11的棋盘，下棋到一半时想保存退出

算法思想：将棋盘模拟成矩阵，仅保存有数据的位置， 也叫压缩数据

package main

import "fmt"

type Node struct{
	row int
	col int
	val int
}

func main() {
	// 定义稀疏数组并打印
	var Array[11][11] int
	Array[1][2] = 2
	Array[2][3] = 4
	
	for _, val := range Array{
		for _, v := range val{
			fmt.Printf("%d\t", v)
		}
		fmt.Println()
	}

	// 将稀疏数组数据压缩存放进SparseNode
	var SparseNode []Node
	firstNode := Node{11,11,0}
	SparseNode = append(SparseNode, firstNode)

	for i, val := range Array{
		for j, v := range val{
			if v != 0{
				node := Node{
					row: i,
					col: j,
					val: v,
				}
				SparseNode = append(SparseNode, node)
			}
		}
	}

	//将存放的压缩数据打印
	for i, node := range SparseNode{
		fmt.Printf("%d: %d %d %d\n", i, node.row, node.col, node.val)
	}

	// 将压缩数据还原成数组
	var newArray[11][11] int
	for i, node := range SparseNode{
		if i !=0{
			newArray[node.row][node.col] = node.val
		}

	}

	// 再次验证
	for _, val := range newArray{
		for _, v := range val{
			fmt.Printf("%d\t", v)
		}
		fmt.Println()
	}

}

运行结果：

注意事项：
1、要保存下棋盘的行和列
2、读取时要记得第一列是棋盘的行和列，否则容易出现数组越界