稀疏数组(golang实现)

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

package main

import (
	"fmt"
)

type ValNode struct {
	row int
	col int
	val int
}

func main() {
	//一、先创建一个原始数组
	var chessMap [11][11]int
	chessMap[1][2] = 1 //黑子
	chessMap[2][3] = 2 //蓝子

	//输出原始数组
	for _, v := range chessMap {
		for _, v2 := range v {
			fmt.Printf("%d\t", v2)
		}
		fmt.Println()
	}

	//二、转成稀疏数组
	//1、遍历chessMap，如果发现有一个元素的值不为0，创建一个node结构体
	//2、将其放入到对应的切片中即可
	var sparseArr []ValNode
	//标准的一个稀疏数组应该还有一个记录元素的二维数组的规模（行和列，默认值）
	//创建一个ValNode值节点
	valNode := ValNode{
		row: 11,
		col: 11,
		val: 0,
	}
	sparseArr = append(sparseArr, valNode)
	//遍历
	for i, v := range chessMap {
		for j, v2 := range v {
			if v2 != 0 {
				//创建一个ValNode值节点
				valNode := ValNode{
					row: i,
					col: j,
					val: v2,
				}
				sparseArr = append(sparseArr, valNode)
			}
		}
	}
	//输出稀疏数组
	fmt.Println("当前的稀疏数组是：")
	for i, valNode := range sparseArr {
		fmt.Printf("%d: %d %d %d\n", i, valNode.row, valNode.col, valNode.val)
	}
	//三、恢复原始的数组
	//1、这里使用稀疏数组恢复
	//2、先创建一个原始数组
	var chessMap2 [11][11]int
	//遍历稀疏数组(文件的每一行)
	for i, valNode := range sparseArr {
		if i != 0 { //跳过第一行的数据
			chessMap2[valNode.row][valNode.col] = valNode.val
		}
	}
	//输出chessMap2
	fmt.Println("恢复后的原始数据：")
	for _, v := range chessMap2 {
		for _, v2 := range v {
			fmt.Printf("%d\t", v2)
		}
		fmt.Println()
	}
}

运行结果：

二、 

1、将这个稀疏数组，存盘  

2、打开这个文件，恢复原始数组

 

package main

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

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

//文件读取转成原始数据
func ReadData(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("%d\t", v1)
		}
		fmt.Println()
	}
}

func main() {

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

	// 看看原始数据
	for _, v := range chessmap {
		for _, v1 := range v {
			fmt.Printf("%d\t", 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,
				})
			}
		}
	}
	// 稀疏数组存盘
	filepath := "c:/test.txt"
	file, err := os.OpenFile(filepath, os.O_WRONLY|os.O_CREATE, 0666)
	if err != nil {
		fmt.Printf("open file err=%v\n", 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()

	// 稀疏数据从磁盘读取转换成原始数据
	ReadData(filepath)
}

运行结果如下：

文件夹

 

 

参考：尚硅谷韩顺平Go语言核心编程

 

文件编程：golang学习（十七）：文件编程

 

---

欢迎大家指正补充，感谢阅读。