稀疏算法

需求：有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、讀取時要記得第一列是棋盤的行和列，否則容易出現數組越界