1.需求: 编写五子棋程序存盘退出和续上盘功能

按照原始方式的二维数组问题

因为该二维数组很多值是默认值 0,因此记录了很多没有意义的数剧

2.基本介绍

当一个数组中大部分元素为 0 或者为同一个值的数组时候,可以使用稀疏数组来保存该数组

稀疏数组处理方法:

1 记录数组一共几行几列,有多少个不同值

2 思想: 把具有不同元素的行列记录在一个小规模数组中

实现

1. 使用稀疏数组,来保留二维数组(地图,棋盘等)

2. 把稀疏数组存盘, 并且可以重新恢复原来的二维码数组

3. 思路分析

代码实现

package main
import (
    "bufio"
    "encoding/json"
    "fmt"
    "io"
    "os"
)
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.Printf("\n")
    }
    // 存储到稀疏数组
    var sparseArr []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{
                    Row: i,
                    Col: j,
                    Val: v2,
                }
                sparseArr = append(sparseArr, valNode)
            }
        }
    }
    // 输出稀疏数组
    for i, node := range sparseArr {
        fmt.Printf("%v : %v \n", i, node)
    }
    // 存盘
    filePath := "/Users/mac/go/src/go_code/05/0501/exp1/chess.data"
    file, err := os.OpenFile(filePath, os.O_CREATE | os.O_RDWR, 0666)
    if err != nil {
        fmt.Printf("write open err : %v \n", err)
    }
    defer file.Close()
    wf := bufio.NewWriter(file)
    fmt.Printf("sparseArr = %v \n", sparseArr)
    cont, err := json.Marshal(sparseArr)
    if err != nil {
        fmt.Printf("json err: %v \n", err)
    }
    fmt.Printf("sparseArr json := %v \n", string(cont))
    wf.WriteString(string(cont))
    wf.Flush()
    // 读取数据
    file2, err := os.Open(filePath)
    if err != nil {
        fmt.Printf("read open err : %v \n", err)
    }
    defer file2.Close()
    rf := bufio.NewReader(file2)
    str := ""
    for  {
        str, err = rf.ReadString('\n')
        if (err == io.EOF) {
            break
        }
    }
    fmt.Printf("str = %v \n", str)
    var arr1 []ValNode
    err = json.Unmarshal([]byte(str), &arr1)
    fmt.Printf("arr1 = %v \n", arr1)
    var chessCap ValNode
    chessCap = arr1[0]
    fmt.Printf("chess cap : %v \n", chessCap)
    // 恢复数组
    var chessMap2 [11][11]int
    //var chessMap2 [r][c]int
    for i, valNode := range sparseArr {
        if i == 0 {
            continue
        }
        chessMap2[valNode.Row][valNode.Col] = valNode.Val
    }
    // 源数组.
    for _, v := range chessMap2 {
        for _, v2 := range v {
            fmt.Printf("%d\t", v2)
        }
        fmt.Printf("\n")
    }
}