go语言稀疏矩阵,队列
Sparse Array
将一个二维数组中无效的值存储起来,然后将有效的数字存储成row、col、value 形式,如下:
/*
row col value
11 11 0 // 第一行存储的是二维数组的大小,即数据的默认值
1 2 1 // 剩下的数据存储的是 如 第 1 行,第二个元素的值是 1,下面的以此类推
2 3 2
*/
package main
import (
"bufio"
"fmt"
"io"
"os"
"strconv"
"strings"
)
type Node struct {
row int
col int
value int
}
func output(array [11][11]int) {
for _, v1 := range array {
for _, v2 := range v1 {
fmt.Print(v2, "\t")
}
fmt.Println()
}
// fmt.Println(" asdaaaaadddddddddddddddddddddddd")
// for i := 0; i < 11; i++ {
// for j := 0; j < 11; j++ {
// fmt.Print(array[i][j], "\t")
// }
// fmt.Println()
// }
// 将数据保存到稀疏矩阵
// sparserArray = append(sparserArray, Node{11, 11, 0})
}
func write(sparserArray []Node) {
// 将数据存入到文件中
file, err := os.OpenFile("E:\\go\\src\\DataStructure\\sparsearray\\demo1\\sparserArray.txt",
os.O_CREATE|os.O_WRONLY, 0666)
// file, err := os.Open("E:\\go\\src\\DataStructure\\sparsearray\\demo1\\sparserArray.txt")
if err != nil {
fmt.Println("kjkk")
return
}
defer file.Close()
fmt.Println(sparserArray)
writer := bufio.NewWriter(file)
for _, v := range sparserArray {
// if v.value != 0 {
info := fmt.Sprintf("%d\t%d\t%d\r\n",
v.row, v.col, v.value)
fmt.Println("....", info)
n, err := writer.WriteString(info)
if err != nil {
fmt.Println("写入失败", n)
}
// 将数据保存的文件中
writer.Flush()
fmt.Println("n=", n)
// }
}
fmt.Println("写入文件成功")
}
func read() (array [11][11]int) {
file, err := os.Open("E:\\go\\src\\DataStructure\\sparsearray\\demo1\\sparserArray.txt")
if err != nil {
return
}
defer file.Close()
reader := bufio.NewReader(file)
str := ""
for {
str, err = reader.ReadString('\n')
if err == io.EOF {
break
}
// fmt.Println("str=", str)
str = strings.Trim(str, "\r\n")
strs := strings.Split(str, "\t")
// 将数据存储到array中
// fmt.Println("strs=", strs[0])
// fmt.Println(strs[1])
// fmt.Println(strs[2])
i, err := strconv.Atoi(strs[0])
j, err := strconv.Atoi(strs[1])
value, err := strconv.Atoi(strs[2])
if err != nil {
return
}
// if i == 0 && j == 0 {
// continue
// }
array[i][j] = value
}
output(array)
return
}
func main() {
var array [11][11]int
var sparserArray []Node
array[1][2] = 1
array[2][3] = 2
// 将数据存入稀疏矩阵中
for i, v1 := range array {
for j, v2 := range v1 {
if v2 != 0 {
sparserArray = append(sparserArray, Node{i, j, v2})
}
}
}
fmt.Println("行\t列\t值")
for _, v := range sparserArray {
fmt.Println(v.row, "\t", v.col, "\t", v.value)
}
write(sparserArray)
output(array)
fmt.Println()
fmt.Println()
var array1 [11][11]int
array1 = read()
output(array1)
}
Queue
队列可以使用数组和链表实现, 数据是以先进先出的形式来存取的, Maxsize该队列的最大容量,其中front 是指向对首的指针,指向队首但是不含队首的元素,随着数据的输出而变化,每取出一个数据就加1,而rear 是指向队尾的指针,指向队尾,包含队尾的元素,随着数据的输入而变化,每存入一个数据就加1,当队列为空的时候,front== rear, 当尾指针小于等于队列的最大下标Maxsize - 1, 则将数据存入rear 所指向的数组元素中, 否则无法存入数据。 当rear == Maxsize - 1 时,队列满,
数组实现队列如下:
// 数组实现非环形队列
package main
import (
"errors"
"fmt"
"os"
)
type Queue struct {
Maxsize int
array [4]int
front int // 指向队首但是不含队首的元素
rear int // 指向队尾,包含队尾的元素
}
func InitQueue() *Queue {
return &Queue{
Maxsize: 4,
front: -1,
rear: -1,
}
}
// 向队列添加数据
func (this *Queue) AddQueue(val int) (err error) {
// 先判断队列是否已满
if this.rear == this.Maxsize-1 { // rear 时队列的队尾,包含最后的元素
return errors.New("queue full")
}
this.rear++
this.array[this.rear] = val
return
}
// 向队列添加数据
func (this *Queue) GetQueue() (val int, err error) {
// 先判断队列是否空
if this.rear == this.front { // rear 时队列的队尾,包含最后的元素
return val, errors.New("queue empty")
}
this.front++
val = this.array[this.front]
return
}
// 显示队列中的数据
func (this *Queue) showQueue() {
// if this.front < this.rear {
for i := this.front + 1; i <= this.rear; i++ {
fmt.Printf("array[%d]=%d\t", i, this.array[i])
}
}
func main() {
// 数组实现
// 创建非环形队列
queue := InitQueue()
// 向队列添加元素
var key string
var val int
for {
fmt.Println()
fmt.Println("\t\t\t1 输入add 向队列添加数据")
fmt.Println("\t\t\t2 输入get 从队列取出数据")
fmt.Println("\t\t\t3 输入show 显示队列的所有数据")
fmt.Println("\t\t\t4 输入exit 退出")
fmt.Scanf("%s\n", &key)
switch key {
case "add":
fmt.Println("输入要添加的数据")
fmt.Scanf("%d\n", &val)
err := queue.AddQueue(val)
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println("加入队列成功")
}
case "get":
fmt.Println("从队列取出数据:")
val, err := queue.GetQueue()
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println("val=", val)
}
case "show":
fmt.Println("显示队列的所有数据")
queue.showQueue()
case "exit":
os.Exit(0)
}
}
}
// 数组实现环形数据结构
package main
import (
"errors"
"fmt"
"os"
)
type Queue struct {
Maxsize int
array [5]int
head int
tail int
}
func InitQueue() *Queue {
return &Queue{
Maxsize: 5, // 环形队列的最大空间时 数组长度减1
head: 0,
tail: 0,
}
}
func (this *Queue) Push(val int) (err error) {
// 先判断队列是否满
if this.IsFull() {
return errors.New("队列满")
}
// 队尾指针指向的空间 但不包含队尾的元素
this.array[this.tail] = val
this.tail = (this.tail + 1) % this.Maxsize
return
}
func (this *Queue) Pop() (val int, err error) {
if this.IsEmpty() {
return val, errors.New("队列空")
}
// 队首指针,包含指向空间的元素
val = this.array[this.head]
this.head = (this.head + 1) % this.Maxsize
return
}
func (this *Queue) Show() {
if this.Size() == 0 {
fmt.Println("队列为空")
}
head := this.head
// 队列中有多少个元素就循环多少次
for i := 0; i < this.Size(); i++ {
fmt.Printf("array[%d]=%d\t", head, this.array[head])
head = (head + 1) % this.Maxsize
}
}
// 判断队列是否满
func (this *Queue) IsFull() bool {
return (this.tail+1)%this.Maxsize == this.head
}
// 判断队列是否空
func (this *Queue) IsEmpty() bool {
return this.head == this.tail
}
// 获取队列的元素个数
func (this *Queue) Size() int {
return (this.tail + this.Maxsize - this.head) % this.Maxsize
}
func main() {
// 数组实现
// 创建环形队列
queue := InitQueue()
// 向队列添加元素
var key string
var val int
for {
fmt.Println()
fmt.Println("\t\t\t1 add 向队列添加数据")
fmt.Println("\t\t\t2 get 从队列取出数据")
fmt.Println("\t\t\t3 show 显示队列的所有数据")
fmt.Println("\t\t\t4 exit 退出")
fmt.Scanf("%s\n", &key)
switch key {
case "add":
fmt.Println("输入要添加的数据")
fmt.Scanf("%d\n", &val)
err := queue.Push(val)
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println("加入队列成功")
}
case "get":
fmt.Println("从队列取出数据:")
val, err := queue.Pop()
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println("val=", val)
}
case "show":
fmt.Println("显示队列的所有数据")
queue.Show()
case "exit":
os.Exit(0)
}
}
}
fmt.Println(err.Error())
} else {
fmt.Println("加入队列成功")
}
case "get":
fmt.Println("从队列取出数据:")
val, err := queue.Pop()
if err != nil {
fmt.Println(err.Error())
} else {
fmt.Println("val=", val)
}
case "show":
fmt.Println("显示队列的所有数据")
queue.Show()
case "exit":
os.Exit(0)
}
}
}