go语言稀疏矩阵,队列

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)

	}
}

}