其他分享
首页 > 其他分享> > GoLang 数据结构(稀疏数组)

GoLang 数据结构(稀疏数组)

作者：互联网

  1 package main
  2 
  3 import (
  4     "bufio"
  5     "fmt"
  6     "io"
  7     "os"
  8     "strconv"
  9     "strings"
 10 )
 11 
 12 //DataNode 数据节点
 13 type DataNode struct {
 14     hang  int //行,存储原数据的位置行
 15     lie   int //列,存储原数据的位置列
 16     value int //值,存储原数据的值
 17 }
 18 
 19 //CreateDyadicArray 创建二维数组
 20 func CreateDyadicArray() [11][11]int {
 21 
 22     var chessBoard [11][11]int
 23     chessBoard[1][2] = 1 //假设为黑子的位置
 24     chessBoard[2][3] = 2 //假设为白子的位置
 25 
 26     /*输出查看结果*/
 27     fmt.Println("↓原始数据↓")
 28     for _, v := range chessBoard {
 29         for _, v2 := range v {
 30             fmt.Printf("%v\t", v2)
 31         }
 32         fmt.Println()
 33     }
 34     return chessBoard
 35 }
 36 
 37 //CreateSparseArray 创建稀疏数组
 38 func CreateSparseArray(chessBoard [11][11]int) []DataNode {
 39     /*    创建切片    */
 40     var dataNodeSlice []DataNode
 41 
 42     /* 标准 稀疏数组 应该存储着原始数据的行和列和值信息 */
 43     dataNode := DataNode{
 44         hang:  11,
 45         lie:   11,
 46         value: 0,
 47     }
 48 
 49     dataNodeSlice = append(dataNodeSlice, dataNode)
 50 
 51     /* 遍历开始 */
 52     for i, v := range chessBoard {
 53         for j, v2 := range v {
 54             if v2 != 0 {
 55                 /* 创建datanode结构体实例化对象 */
 56                 dataNode := DataNode{
 57                     hang:  i,
 58                     lie:   j,
 59                     value: v2,
 60                 }
 61                 /* 将创建好的结构体对象 添加到 dataNodeSlice切片中 */
 62                 dataNodeSlice = append(dataNodeSlice, dataNode)
 63             }
 64         }
 65         fmt.Println()
 66     }
 67 
 68     /* 输出稀疏数组 对比 原始数组 */
 69     fmt.Println("↓稀疏数组数据↓")
 70     for i, v := range dataNodeSlice {
 71         fmt.Printf("%v %v %v \n", i, v.hang, v.lie)
 72     }
 73     return dataNodeSlice
 74 }
 75 
 76 //WriteDataToFile 将数据写入文件
 77 func WriteDataToFile(dataNodeSlice []DataNode) {
 78     /* 创建写入路径 */
 79     WritefilePath := "d:/dataNodeSlice.data"
 80 
 81     /* 获取文件句柄file  */
 82     file, err := os.OpenFile(WritefilePath, os.O_WRONLY|os.O_CREATE, 233)
 83     if err != nil {
 84         fmt.Println("打开文件失败!")
 85         return
 86     }
 87 
 88     /* 延迟关闭,当文件句柄使用完毕时,自动关闭文件句柄 */
 89     defer file.Close()
 90 
 91     /* 获取 writer */
 92     writer := bufio.NewWriter(file)
 93     for _, v := range dataNodeSlice {
 94         data := fmt.Sprintf(" %v %v %v \n", v.hang, v.lie, v.value)
 95         writer.WriteString(data)
 96     }
 97 
 98     /*刷新数据,不然不显示*/
 99     writer.Flush()
100     fmt.Printf("写入文件成功,Path:%v\n", WritefilePath)
101 }
102 
103 //ReadDateToArray 读取数据到数组
104 func ReadDateToArray() (NewArray [11][11]int) {
105     ReadFilePath := "d:/dataNodeSlice.data"
106     file, err := os.OpenFile(ReadFilePath, os.O_RDONLY, 233)
107     if err != nil {
108         fmt.Println("读取文件失败!")
109         return
110     }
111     defer file.Close()
112 
113     reader := bufio.NewReader(file)
114     for {
115         fmt.Println("进入循环读取...")
116         str, err := reader.ReadString('\n')
117         if err != nil {
118             fmt.Println("reader.ReadString err\t", err)
119             return
120         }
121 
122         /*  分割 ( 去除(从str,到换行) 内容,的" 空格 ") */
123         data := strings.Split(strings.TrimRight(str, "\n"), " ")
124 
125         /*  将数据从string类型转换成int类型 */
126         hang, _ := strconv.Atoi(data[1])
127         lie, _ := strconv.Atoi(data[2])
128         value, _ := strconv.Atoi(data[3])
129 
130         /* 跳过第一行数据,暂不做处理 */
131         if hang == 11 || lie == 11 {
132             continue
133         }
134 
135         fmt.Printf("hang:%v\t", hang)
136         fmt.Printf("lie%v\t", lie)
137         fmt.Printf("value%v\t", value)
138 
139         /* 拿到数据 */
140         NewArray[hang][lie] = value
141 
142         /* 读到了末尾 */
143         if err == io.EOF {
144             break
145         }
146 
147     }
148     return NewArray
149 }
150 
151 //PrintData 输出数据
152 func PrintData(NewDataArray [11][11]int) {
153     for _, v := range NewDataArray {
154 
155         fmt.Println(v)
156     }
157 }
158 func main() {
159 
160     /* 稀疏数组案例 */
161 
162     /* 直接存储以上的信息显然数据量太大,这时我们将它转换成 稀疏数组存储呢? */
163     /*思路:遍历chessBoard,如果有值不是0,就将数据的位置信息与值存入结构体切片中*/
164 
165     chessBoard := CreateDyadicArray()
166 
167     dataNodeSlice := CreateSparseArray(chessBoard)
168 
169     WriteDataToFile(dataNodeSlice)
170 
171     NewDataArray := ReadDateToArray()
172 
173     PrintData(NewDataArray)
174 
175     /* 方法2 直接还原稀疏数组 */
176 
177     /* 创建一个要还原的数组 */
178     // var mapArray [11][11]int
179 
180     // for i, v := range dataNodeSlice {
181     //     if i != 0 {
182     //         mapArray[v.hang][v.lie] = v.value
183     //     }
184 
185     // }
186 
187     // fmt.Println("↓稀疏数组还原后的原数组数据↓")
188     // for _, v := range chessBoard {
189     //     for _, v2 := range v {
190     //         fmt.Printf("%v\t", v2)
191     //     }
192     //     fmt.Println()
193     // }
194 }
View Code

 

标签：11,dataNodeSlice,fmt,GoLang,数组,Println,数据结构,chessBoard
来源： https://www.cnblogs.com/alanshreck/p/14161689.html