golang数据结构之稀疏数组

package main

import (
    "bufio"
    fmtioosstrconvstrings"
    // "strconv"
)

func originArr() [11][11]int {
    创建原始数组
    var chessMap [

    chessMap[1][2] = 1
    chessMap[2][3] = 2
    return chessMap
}

func printArr(chessMap [) {
    打印数组
    for _,v1 := range chessMap {
         range v1 {
            fmt.Printf(%dt",v2)
        }
        fmt.Println()
    }
}

存储行、列、值
type valNode struct {
    row   
    col   int
    这里是接口类型，所以值可以是任意类型，不仅仅包含整型和字符型
    value interface{}
}

var sparseArr []valNode

func doParseArr(chessMap [) []valNode {
    稀疏数组
    遍历数组，如果某个值不为零，则将其放置在对应的结构体中
    val := valNode{
        原来数组的行和列以及值
        row:   110初始化存储稀疏数组
    sparseArr = append(sparseArr,val)

    for i,1)">for j,1)"> range v1 {
            if v2 !=  {
                 val valNode
                val.row = i
                val.col = j
                val.value = v2
                sparseArr = range sparseArr {
        fmt.Printf(第%d行，第%d列的值是%dn",j.row,j.col,j.value.())

    }
     sparseArr
}

func writeParseArr(sparseArr []valNode,filepath string将稀疏数组存储
    file,err := os.OpenFile(filepath,os.O_CREATE|os.O_APPEND|os.O_WRONLY,0666)
    if err != nil {
        
    }
    defer file.Close()
     range sparseArr {
        因为读取到的整型，需要转为字符串再进行写入
        将接口赋值给一个变量需要进行类型断言
        str := strconv.Itoa(j.row) + " " + strconv.Itoa(j.col) + " + strconv.Itoa((j.value.(int))) + n
        wriiter := bufio.NewWriter(file)
        wriiter.WriteString(str)
        wriiter.Flush()
         fmt.Printf("第%d行，第%d列的值是%dn",j.value.(int))

    }
}

func readParseArr(filepath string) (newChessMap [初始化数组
    读取存储的文件,并将每行转成
    file,os.O_RDONLY,1)">
    }
    defer file.Close()
    reader := bufio.NewReader(file)
    for {
        str,err := reader.ReadString('')
         nil {
            
        }
        tmp := strings.Split(strings.TrimRight(str,1)">"),1)"> fmt.Println(strings.Split(strings.TrimRight(str,"n")," "))
        r,_ := strconv.Atoi(tmp[])
        c,_ := strconv.Atoi(tmp[])
        v,1)">2])
        if r ==  {
            continue
        }
        newChessMap[r][c] = v
        if err == io.EOF {
            break
        }
    }
     newChessMap
}

func main() {
    chessMap := originArr()
    printArr(chessMap)
    sparseArr := doParseArr(chessMap)
    filepath := data.txt
    writeParseArr(sparseArr,filepath)
    newChessMap := readParseArr(filepath)
    printArr(newChessMap)
}