所谓稀疏数组就是数组中大部分的内容值都未被使用（或都为零），在数组中仅有少部分的空间使用。因此造成内存空间的浪费，为了节省内存空间，并且不影响数组中原有的内容值，我们可以采用一种压缩的方式来表示稀疏数组的内容。

稀疏数组的处理方法：
1. 记录数组一共有几行即列，有多少个不同的值
2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

假设有一个9*7的数组，其内容如下：

在此数组中，共有63个空间，但却只使用了5个元素，造成58个元素空间的浪费。以下我们就使用稀疏数组重新来定义这个数组：

其中在稀疏数组中第一部分所记录的是原数组的列数和行数以及元素使用的个数、第二部分所记录的是原数组中元素的位置和内容。

经过压缩之后，原来需要声明大小为63的数组，而使用压缩后，只需要声明大小为6*3的数组，仅需18个存储空间。

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"
)

type nodeval struct {
	row int
	col int
	val interface{}
}


func ReadSparseArray(filename string) {
	file, err := os.OpenFile(filename, os.O_RDONLY, 0666)
	if err != nil {
		log.Fatalf("%s", err)
	}
	defer file.Close()
	bfrd := bufio.NewReader(file)
	var index = 0
	var arr [][]int
	for {
		line, err := bfrd.ReadBytes('n')
		if err != nil {
			break
		}
		index++
		temp := strings.Split(string(line), " ")
		row, _ := strconv.Atoi(temp[0])
		col, _ := strconv.Atoi(temp[1])
		value, _ := strconv.Atoi(temp[2])
		if index == 1 {
			for i := 0; i < row; i++ {
				var arr_temp []int
				for j := 0; j < col; j++ {
					arr_temp = append(arr_temp, value)
				}
				arr = append(arr, arr_temp)
			}
		}
		if index != 1 {
			arr[row][col] = value
		}
	}
	// 打印数据
	fmt.Println("从磁盘读取后的数据")
	for _, v := range arr {
		for _, v1 := range v {
			fmt.Printf("%dt", v1)
		}
		fmt.Println()
	}
}

func main() {

	var chessmap [11][11]int
	chessmap[1][2] = 1
	chessmap[2][3] = 2
	chessmap[2][2] = 1
	chessmap[3][2] = 2
	chessmap[4][2] = 1
	chessmap[4][1] = 2

	// 查看原始数据
	for _, v := range chessmap {
		for _, v1 := range v {
			fmt.Printf("%dt", v1)
		}
		fmt.Println()
	}

	// 转成稀疏数据
	var sparseArr []nodeval
	// 数据模型
	sparseArr = append(sparseArr, nodeval{
		row: 11,
		col: 11,
		val: 0,
	})
	//创建稀疏数组
	for row, val := range chessmap {
		for col, val1 := range val {
			if val1 != 0 {
				sparseArr = append(sparseArr, nodeval{
					row: row,
					col: col,
					val: val1,
				})
			}
		}
	}

	//输出稀疏数组
	fmt.Println("当前的稀疏数组是：")
	for i, valNode := range sparseArr {
		fmt.Printf("%d: %d %d %dn", i, valNode.row, valNode.col, valNode.val)
	}


	// 稀疏数组存盘
	filepath := "SparseArray.txt"
	file, err := os.OpenFile(filepath, os.O_WRONLY|os.O_CREATE, 0666)
	if err != nil {
		fmt.Printf("open file err=%vn", err)
	}
	defer file.Close()
	writer := bufio.NewWriter(file)
	for _, node := range sparseArr {
		str := fmt.Sprintf("%d %d %d n", node.row, node.col, node.val)
		writer.WriteString(str)
	}
	writer.Flush()

	ReadSparseArray(filepath)
}