Golang学习 Day_15 数据结构01

最新推荐文章于 2024-10-19 14:25:05 发布
最新推荐文章于 2024-10-19 14:25:05 发布
阅读量67 收藏
点赞数
文章标签： 数据结构 golang 学习 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52423136/article/details/129654784
版权

稀疏数组(sparsearray)

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

处理方法：

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

  1. 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。

应用实例

  1. 使用稀疏数组，来保存二维数组

  1. 把稀疏数组存盘，并且可以恢复到原来的二维数组。

原始数组->稀疏数组

package main


import "fmt"


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.Println()
    }


    // 转成稀疏数组 ->算法
    // 1、便历数组，如果一个元素的值不为0，创建node结构体
    // 2、将其放到对应切片中


    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, valNode := range sparseArr {
        fmt.Printf("%d:%d %d %d\n", i, valNode.row, valNode.col, valNode.val)
    }
}

稀疏数组->原始数组

var chessMap2 [11][11]int
    // 遍历 sparseArr
    for i, valNode := range sparseArr {
        // 记录第一行的值
        if i != 0 {
            chessMap2[valNode.row][valNode.col] = valNode.val
        }
    }


    fmt.Println("恢复后的原始数据....")
    for _, v := range chessMap2 {
        for _, v2 := range v {
            fmt.Printf("%d\t", v2)
        }
        fmt.Println()
    }

队列(queue)

队列是一个有序列表，可以使用数组或链表来实现

遵循先入先出的原则。

数组模拟队列

  1. 队列本身是有序列表，若使用数组的结构来存储队列的数据，需要一下声明，其中maxSize是队列的最大容量

  1. 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量front及rear分别及录队列的前后端的下标，front会随着数据输出二改变，而rear则是随着数据输入而改变

package main


import (
    "errors"
    "fmt"
    "os"
)


type Queue struct {
    maxSize int
    array   [5]int // 数组=>模拟队列
    front   int    // 指向队列首
    rear    int    // 只想对俄的尾
}


// 添加数据到队列
func (q *Queue) addQueue(val int) (err error) {


    // 先判断队列是否已满
    if q.rear == q.maxSize-1 {
        return errors.New("queue full")
    }
    q.rear++
    q.array[q.rear] = val
    return
}


// 从队列中取出数据
func (q *Queue) GetQueue() (val int, err error) {
    if q.rear == q.front {
        return -1, errors.New("queue empty")
    }
    q.front++
    val = q.array[q.front]
    return val, err
}


func (q *Queue) ShowQueue() {


    for i := q.front + 1; i <= q.rear; i++ {
        fmt.Printf("array[%d] = %d\n", i, q.array[i])
    }
    fmt.Println()
}


func main() {
    queue := &Queue{
        maxSize: 5,
        front:   -1,
        rear:    -1,
    }


    var key string
    var val int
    for {
        fmt.Println("1.输入add 表示添加数据到队列")
        fmt.Println("2.输入get 表示从队列中获取数据")
        fmt.Println("3.输入show 表示显示队列")
        fmt.Println("4.输入exit 表示显示队列")


        fmt.Scanln(&key)
        switch key {
        case "add":
            fmt.Println("输入你要入队列数")
            fmt.Scanln(&val)
            err := queue.addQueue(val)
            if err == nil {
                fmt.Println("加入队列ok")
            } else {
                fmt.Println(err.Error())
            }
        case "get":
            val, err := queue.GetQueue()
            if err != nil {
                fmt.Print(err.Error())
            } else {
                fmt.Println("从队列中去除了一个数=", val)
            }
        case "show":
            queue.ShowQueue()
        case "exit":
            os.Exit(0)


        }


    }
}

数组模拟环形队列

package main


import (
    "errors"
    "fmt"
    "os"
)


type CircleQueue struct {
    maxSize int
    array   [5]int
    head    int // 指向队列队首
    tail    int // 指向队尾
}


func (q *CircleQueue) Push(val int) (err error) {
    if q.IsFull() {
        return errors.New("queue full")
    }
    q.array[q.tail] = val
    q.tail = (q.tail + 1) % q.maxSize
    return
}


func (q *CircleQueue) Pop() (val int, err error) {
    if q.IsEmpty() {
        return 0, errors.New("qieie empty")
    }
    // head指向队首，并且韩队首元素
    val = q.array[q.head]
    q.head++
    return
}


// 显示队列
func (q *CircleQueue) ListQueue() {
    size := q.Size()
    if size == 0 {
        fmt.Println("队列为空")
    }


    // 设计一个辅助变量
    tempHead := q.head
    for i := 0; i < size; i++ {
        fmt.Printf("arr[%d]=%d\n", tempHead, q.array[tempHead])
        tempHead = (tempHead + 1) % q.maxSize
    }


}


// 判断环形队列为空
func (q *CircleQueue) IsFull() bool {
    return (q.tail+1)%q.maxSize == q.head
}


func (q *CircleQueue) IsEmpty() bool {
    return q.tail == q.head
}


func (q *CircleQueue) Size() int {
    return (q.tail + q.maxSize - q.head) % q.maxSize
}


func main() {
    // 初始化环形队列
    queue := CircleQueue{
        maxSize: 5,
        head:    0,
        tail:    0,
    }


    var key string
    var val int
    for {
        fmt.Println("1.输入add 表示添加数据到队列")
        fmt.Println("2.输入get 表示从队列中获取数据")
        fmt.Println("3.输入show 表示显示队列")
        fmt.Println("4.输入exit 表示显示队列")


        fmt.Scanln(&key)
        switch key {
        case "add":
            fmt.Println("输入你要入队列数")
            fmt.Scanln(&val)
            err := queue.Push(val)
            if err == nil {
                fmt.Println("加入队列ok")
            } else {
                fmt.Println(err.Error())
            }
        case "get":
            val, err := queue.Pop()
            if err != nil {
                fmt.Print(err.Error())
            } else {
                fmt.Println("从队列中去除了一个数=", val)
            }
        case "show":
            queue.ListQueue()
        case "exit":
            os.Exit(0)


        }


    }
}

链表

单链表

package main


import "fmt"


type LinkNode struct {
    no       int
    name     string
    nickname string
    next     *LinkNode
}


// 编写第一种插入方法，在单链表的最后加入
func InsertHEroNode(head *LinkNode, newHeroNode *LinkNode) {
    // 1.先找到该链表的最后这个节点
    // 2.创建一个辅助节点
    temp := head
    for {
        if temp.next == nil {
            break
        }
        temp = temp.next
    }
    temp.next = newHeroNode
}


func ListHeroNode(head *LinkNode) {
    temp := head


    if temp.next == nil {
        fmt.Println("空空如也。。。")
        return
    }


    for {
        fmt.Printf("[%d , %s, %s]==>", temp.next.no, temp.next.name, temp.next.nickname)
        temp = temp.next
        if temp.next == nil {
            break
        }
    }
}


func main() {
    // 创建一个头结点
    head := &LinkNode{}
    hero1 := &LinkNode{
        no:       1,
        name:     "宋江",
        nickname: "及时雨",
    }


    hero2 := &LinkNode{
        no:       2,
        name:     "卢俊义",
        nickname: "玉麒麟",
    }
    InsertHEroNode(head, hero1)
    InsertHEroNode(head, hero2)
    ListHeroNode(head)
}

单链表插入

package main


import "fmt"


type LinkNode struct {
    no       int
    name     string
    nickname string
    next     *LinkNode
}


// 编写第一种插入方法，在单链表的最后加入
func InsertHeroNode(head *LinkNode, newHeroNode *LinkNode) {
    // 1.先找到该链表的最后这个节点
    // 2.创建一个辅助节点
    temp := head
    for {
        if temp.next == nil {
            break
        }
        temp = temp.next
    }
    temp.next = newHeroNode
}


func InsertHeroNode2(head *LinkNode, newHeroNode *LinkNode) {


    temp := head
    flag := true
    for {
        if temp.next == nil {
            break
        } else if temp.next.no > newHeroNode.no {
            break
        } else if temp.next.no == newHeroNode.no {
            flag = false
            break
        }
        temp = temp.next
    }


    if !flag {
        fmt.Println("对不起，已经存在no=", newHeroNode.no)
        return
    } else {
        newHeroNode.next = temp.next
        temp.next = newHeroNode
    }
}


func ListHeroNode(head *LinkNode) {
    temp := head


    if temp.next == nil {
        fmt.Println("空空如也。。。")
        return
    }


    for {
        fmt.Printf("[%d , %s, %s]==>", temp.next.no, temp.next.name, temp.next.nickname)
        temp = temp.next
        if temp.next == nil {
            break
        }
    }
}


func main() {
    // 创建一个头结点
    head := &LinkNode{}
    hero1 := &LinkNode{
        no:       1,
        name:     "宋江",
        nickname: "及时雨",
    }


    hero2 := &LinkNode{
        no:       2,
        name:     "卢俊义",
        nickname: "玉麒麟",
    }


    hero3 := &LinkNode{
        no:       3,
        name:     "林冲",
        nickname: "豹子头",
    }
    InsertHeroNode2(head, hero1)
    InsertHeroNode2(head, hero2)
    InsertHeroNode2(head, hero3)
    ListHeroNode(head)
}

单链表删除

package main


import "fmt"


type LinkNode struct {
    no       int
    name     string
    nickname string
    next     *LinkNode
}


// 编写第一种插入方法，在单链表的最后加入
func InsertHeroNode(head *LinkNode, newHeroNode *LinkNode) {
    // 1.先找到该链表的最后这个节点
    // 2.创建一个辅助节点
    temp := head
    for {
        if temp.next == nil {
            break
        }
        temp = temp.next
    }
    temp.next = newHeroNode
}


func InsertHeroNode2(head *LinkNode, newHeroNode *LinkNode) {


    temp := head
    flag := true
    for {
        if temp.next == nil {
            break
        } else if temp.next.no > newHeroNode.no {
            break
        } else if temp.next.no == newHeroNode.no {
            flag = false
            break
        }
        temp = temp.next
    }


    if !flag {
        fmt.Println("对不起，已经存在no=", newHeroNode.no)
        return
    } else {
        newHeroNode.next = temp.next
        temp.next = newHeroNode
    }
}


func ListHeroNode(head *LinkNode) {
    temp := head


    if temp.next == nil {
        fmt.Println("空空如也。。。")
        return
    }


    for {
        fmt.Printf("[%d , %s, %s]==>", temp.next.no, temp.next.name, temp.next.nickname)
        temp = temp.next
        if temp.next == nil {
            break
        }
    }
}


func DelHerNode(head *LinkNode, id int) {
    temp := head
    flag := false
    // 找到要删除的节点
    for {
        if temp.next == nil {
            break
        } else if temp.next.no == id {
            flag = true
            break
        }
        temp = temp.next
    }
    if flag {
        temp.next = temp.next.next
    } else {
        fmt.Println("要删除的结点不存在")
    }


}


func main() {
    // 创建一个头结点
    head := &LinkNode{}
    hero1 := &LinkNode{
        no:       1,
        name:     "宋江",
        nickname: "及时雨",
    }


    hero2 := &LinkNode{
        no:       2,
        name:     "卢俊义",
        nickname: "玉麒麟",
    }


    hero3 := &LinkNode{
        no:       3,
        name:     "林冲",
        nickname: "豹子头",
    }
    InsertHeroNode2(head, hero1)
    InsertHeroNode2(head, hero2)
    InsertHeroNode2(head, hero3)
    DelHerNode(head, 2)
    ListHeroNode(head)
}
余木榆木
关注
Golang学习笔记
技术宇宙
01-05 2022
目录特点天然并发函数可以返回多个值开发目录结构Golang 执行流程分析参考 特点 Go 语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率动态语言开发维护的高效率 使用一个表达式来形容 Go 语言：Go = C + Python 说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发 天然并发 从语言层面支持并发，实现简单 goroutine，轻量级线程，可实现大并发处理，高效利用多核 基于 CSP 并发模型(Communicating S
Golang学习 Day_18 数据结构02
qq_52423136的博客
03-22 59
Golang学习 Day_18 数据结构02
Golang学习 Day_09
qq_52423136的博客
03-10 112
Golang学习 Day_09 map,面向“对象”编程，结构体，方法 “如果你无力去做那种惊天动地的大事，那就满怀热情地做好眼前的小事”
Golang学习 Day_12
qq_52423136的博客
03-13 209
Golang学习 Day_12
Golang学习 Day_14
qq_52423136的博客
03-15 144
Golang学习 Day_14
Golang学习 Day_01
qq_52423136的博客
03-02 62
go语言学习Day_01
golang学习【7】字符串和常用数据结构
loo_Charles_ool的博客
04-17 752
golang字符串和常用数据结构学习介绍
Golang学习 Day_04
qq_52423136的博客
03-05 173
Golang学习 Day_04
Golang学习 Day_02
qq_52423136的博客
03-03 94
Golang学习 Day_02 因为是从语雀笔记上直接贴过来的，有些地方格式不舒服见谅
Golang学习 Day_19 GORM
qq_52423136的博客
03-26 146
Golang学习 Day_19 GORM
日常学习总结golang(day1)---数组、切片、指针
lili9415的博客
03-24 265
对于go语言的语法还是简单易懂的，不过还是要多看看，加深一下印象。而只学基本语法是根本无法满足开发的需求的。最近跟着视频学习，除了基本语法还有并发、中间件、日志库、互联网协议、Mysql、redis、gin、docker等等。为了以后自己复习方便，看完后进行一些总结。有需要的同学也可以看一下！ 1. for…range(键值循环) Go语言中可以使用for...range遍历数组、切片、字符串、...
Golang学习，指针，循环控制相关
weixin_44048140的博客
04-19 954
这里总结的Golang 笔记只适合有点编程基础的人看，比如Java ==补充：==语言规范，由26个英文字符，0-9，_去做命名的，且不能以数字开头，严格区分大小写，不能出现空格。（这里需要注意的是_不能单独作为变量名去使用，单独的情况下只能作为占位符去使用）。 eg：fmt下面的这个库函数使用 func main() { var a int b,_ := fmt.Scanf("%d", &a) fmt.Println("a的值： ", a, "b的值： ", b) } // 打印的结.
【golang项目-GeeCache】动手写分布式缓存 day1 - 实现LRU算法
csxylrf的博客
04-16 528
LRU(Least Recently Used) 最近最少使用 算法 ，系统认为如果这个数据最近使用过那么它被再次使用的概率会高，所以系统会先淘汰最久没被使用的数据。
golang实现的布隆过滤器_Golang中的布隆过滤器
weixin_39781783的博客
02-15 130
目录1. 布隆过滤器的概念布隆过滤器(Bloom Filter) 是由 Howard Bloom在1970年提出的二进制向量数据结构，它具有很好的空间和时间效率，被用来检测一个元素是不是集合中的一个成员，即判定 “可能已存在和绝对不存在” 两种情况。如果检测结果为是，该元素不一定在集合中；但如果检测结果为否，该元素一定不在集合中,因此Bloom filter具有100%的召回率。2. 布隆过滤器应...
数据结构与算法：高级数据结构与实际应用
weidl001的博客
10-16 1098
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
【数据结构】AVL树（C++实现）
weixin_73914025的博客
10-13 762
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在Olog2nO(log_2 n)Olog。
七大经典排序算法优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序、归并排序代码详解
weixin_64593595的博客
10-15 1736
本文深入探讨了七大经典排序算法的优化：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序和归并排序。适合需要稳定性排序的场景，通过对这些算法的分析和优化，能够根据具体需求选择合适的排序方法，从而提高程序性能和效率。
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 600
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构——链表，哈希表
最新发布
m0_66925868的博客
10-19 272
若有错误与不足请指出，关注DPT一起进步吧！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值