go标准包系列-算法与数据结构相关包

已于 2023-07-08 21:40:43 修改
阅读量86 收藏
点赞数
分类专栏： golang 文章标签： golang
于 2023-07-06 10:08:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ocean2017/article/details/131569823
版权

1 sort包

该包实现了四种基本排序算法：插入排序、归并排序、堆排序和快速排序。对数据集合排序时不必考虑应当选择哪一种排序方法，只要实现了 sort.Interface 定义的三个方法：获取数据集合长度的 Len() 方法、比较两个元素大小的 Less() 方法和交换两个元素位置的 Swap() 方法，就可以顺利对数据集合进行排序。

1.1 接口定义

定义

type Interface interface {
        // 获取数据集合元素个数
        Len() int
        // 如果 i 索引的数据小于 j 索引的数据，返回 true，且不会调用下面的 Swap()，即数据升序排序。
        Less(i, j int) bool
        // 交换 i 和 j 索引的两个元素的位置
        Swap(i, j int)
}

排序方法

func Sort(data Interface)

Reverse实现逆序排序

func Reverse(data Interface) Interface

sort.Sort(sort.Reverse(stus))
fmt.Println(stus)

Reverse的实现

// 定义了一个 reverse 结构类型，嵌入 Interface 接口
type reverse struct {
    Interface
}

//reverse 结构类型的 Less() 方法拥有嵌入的 Less() 方法相反的行为
//Len() 和 Swap() 方法则会保持嵌入类型的方法行为
func (r reverse) Less(i, j int) bool {
    return r.Interface.Less(j, i)
}

// 返回新的实现 Interface 接口的数据类型
func Reverse(data Interface) Interface {
    return &reverse{data}
}

顺序认定

func IsSorted(data Interface) bool {
    n := data.Len()
    for i := n - 1; i > 0; i-- {
        if data.Less(i, i-1) {
            return false
        }
    }
    return true
}

示例：

package main

import (
    "fmt"
    "sort"
)

// 学生成绩结构体
type StuScore struct {
    name  string    // 姓名
    score int   // 成绩
}

type StuScores []StuScore

//Len()
func (s StuScores) Len() int {
    return len(s)
}

//Less(): 成绩将有低到高排序
func (s StuScores) Less(i, j int) bool {
    return s[i].score < s[j].score
}

//Swap()
func (s StuScores) Swap(i, j int) {
    s[i], s[j] = s[j], s[i]
}

func main() {
    stus := StuScores{
                {"alan", 95},
                {"hikerell", 91},
                {"acmfly", 96},
                {"leao", 90},
                }

    // 打印未排序的 stus 数据
    fmt.Println("Default:\n\t",stus)
    //StuScores 已经实现了 sort.Interface 接口 , 所以可以调用 Sort 函数进行排序
    sort.Sort(stus)
    // 判断是否已经排好顺序，将会打印 true
    fmt.Println("IS Sorted?\n\t", sort.IsSorted(stus))
    // 打印排序后的 stus 数据
    fmt.Println("Sorted:\n\t",stus)
}

最后一个方法：Search()

func Search(n int, f func(int) bool) int
1.2 sort包中支持的数据类型

sort包原生支持[]int、[]float64 和[]string 三种内建数据类型切片的排序操作

1.2.1 IntSlice 类型及[]int 排序

定义

type IntSlice []int
func (p IntSlice) Len() int           { return len(p) }
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
//IntSlice 类型定义了 Sort() 方法，包装了 sort.Sort() 函数
func (p IntSlice) Sort() { Sort(p) }
//IntSlice 类型定义了 SearchInts() 方法，包装了 SearchInts() 函数
func (p IntSlice) Search(x int) int { return SearchInts(p, x) }

调用

func Ints(a []int) { Sort(IntSlice(a)) }

示例

s := []int{5, 2, 6, 3, 1, 4} // 未排序的切片数据
sort.Ints(s)
fmt.Println(s) // 将会输出[1 2 3 4 5 6]

s := []int{5, 2, 6, 3, 1, 4} // 未排序的切片数据
sort.Sort(sort.Reverse(sort.IntSlice(s)))
fmt.Println(s) // 将会输出[6 5 4 3 2 1]
1.2.2 Float64Slice 类型及[]float64 排序

定义

type Float64Slice []float64

func (p Float64Slice) Len() int           { return len(p) }
func (p Float64Slice) Less(i, j int) bool { return p[i] < p[j] || isNaN(p[i]) && !isNaN(p[j]) }
func (p Float64Slice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p Float64Slice) Sort() { Sort(p) }
func (p Float64Slice) Search(x float64) int { return SearchFloat64s(p, x) }

调用

func Float64s(a []float64)  
func Float64sAreSorted(a []float64) bool
func SearchFloat64s(a []float64, x float64) int
1.2.3 StringSlice 类型及[]string 排序
type StringSlice []string

func (p StringSlice) Len() int           { return len(p) }
func (p StringSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p StringSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p StringSlice) Sort() { Sort(p) }
func (p StringSlice) Search(x string) int { return SearchStrings(p, x) }

func Strings(a []string)
func StringsAreSorted(a []string) bool
func SearchStrings(a []string, x string) int

2 container

2.1 堆

定义：

type Interface interface {
    sort.Interface
    Push(x interface{}) // add x as element Len()
    Pop() interface{}   // remove and return element Len() - 1.
}

实现

type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
    *h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
    old := *h
    n := len(old)
    x := old[n-1]
    *h = old[0 : n-1]
    return x
}
2.2 链表

接口定义

type Element struct {
    next, prev *Element  // 上一个元素和下一个元素
    list *List  // 元素所在链表
    Value interface{}  // 元素
}

type List struct {
    root Element  // 链表的根元素
    len  int      // 链表的长度
}

示例：

// This example demonstrates an integer heap built using the heap interface.
package main

import (
    "container/list"
    "fmt"
)

func main() {
    list := list.New()
    list.PushBack(1)
    list.PushBack(2)

    fmt.Printf("len: %v\n", list.Len())
    fmt.Printf("first: %#v\n", list.Front())
    fmt.Printf("second: %#v\n", list.Front().Next())
}

output:
len: 2
first: &list.Element{next:(*list.Element)(0x2081be1b0), prev:(*list.Element)(0x2081be150), list:(*list.List)(0x2081be150), Value:1}
second: &list.Element{next:(*list.Element)(0x2081be150), prev:(*list.Element)(0x2081be180), list:(*list.List)(0x2081be150), Value:2}

调用

type Element
    func (e *Element) Next() *Element
    func (e *Element) Prev() *Element
type List
    func New() *List
    func (l *List) Back() *Element   // 最后一个元素
    func (l *List) Front() *Element  // 第一个元素
    func (l *List) Init() *List  // 链表初始化
    func (l *List) InsertAfter(v interface{}, mark *Element) *Element // 在某个元素后插入
    func (l *List) InsertBefore(v interface{}, mark *Element) *Element  // 在某个元素前插入
    func (l *List) Len() int // 在链表长度
    func (l *List) MoveAfter(e, mark *Element)  // 把 e 元素移动到 mark 之后
    func (l *List) MoveBefore(e, mark *Element)  // 把 e 元素移动到 mark 之前
    func (l *List) MoveToBack(e *Element) // 把 e 元素移动到队列最后
    func (l *List) MoveToFront(e *Element) // 把 e 元素移动到队列最头部
    func (l *List) PushBack(v interface{}) *Element  // 在队列最后插入元素
    func (l *List) PushBackList(other *List)  // 在队列最后插入接上新队列
    func (l *List) PushFront(v interface{}) *Element  // 在队列头部插入元素
    func (l *List) PushFrontList(other *List) // 在队列头部插入接上新队列
    func (l *List) Remove(e *Element) interface{} // 删除某个元素
2.3 环（ring）

接口定义

type Ring struct {
    next, prev *Ring
    Value      interface{}
}

示例

// This example demonstrates an integer heap built using the heap interface.
package main

import (
    "container/ring"
    "fmt"
)

func main() {
    ring := ring.New(3)

    for i := 1; i <= 3; i++ {
        ring.Value = i
        ring = ring.Next()
    }

    // 计算 1+2+3
    s := 0
    ring.Do(func(p interface{}){
        s += p.(int)
    })
    fmt.Println("sum is", s)
}

output:
sum is 6

调用

type Ring
    func New(n int) *Ring  // 初始化环
    func (r *Ring) Do(f func(interface{}))  // 循环环进行操作
    func (r *Ring) Len() int // 环长度
    func (r *Ring) Link(s *Ring) *Ring // 连接两个环
    func (r *Ring) Move(n int) *Ring // 指针从当前元素开始向后移动或者向前（n 可以为负数）
    func (r *Ring) Next() *Ring // 当前元素的下个元素
    func (r *Ring) Prev() *Ring // 当前元素的上个元素
    func (r *Ring) Unlink(n int) *Ring // 从当前元素开始，删除 n 个元素
羽辰不是逗比
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
go标准包系列-文件系统相关包
ocean2017的博客
07-12 164
个成员的[]string，切片成员为目录中文件对象的名字，采用目录顺序。对本函数的下一次调用会返回上一次调用未读取的内容的信息。该接口描述一个文件的元数据信息，它由 Stat 返回。类似，区别在于如果文件是符号链接，那么所返回的信息针对的是符号链接自身（而非符号链接所指向的文件）。则会返回由某个打开文件描述符（Go 中则是当前打开文件 File）所指代文件的相关信息。文件是按字典顺序遍历的，这让输出更漂亮，但也导致处理非常大的目录时效率会降低。指定的目录下的文件树，对每一个该文件树中的目录和文件都会调用。
go常用标准包介绍
Mr.Buffoon
12-18 1817
go标准库包含很多包，详细见https://golang.org/pkg/ 下面摘取部分比较常用的说明一下： strings包 ： 主要是处理字符串的一些函数集合，包括合并、查找、分割、比较、后缀检查、索引、大小写处理等等。 strings与bytes的函数接口功能基本一致。 bytes包： bytes包提供了对字节切片进行读写操作的一系列函数。 字节切片处理的函数比较多，分为基本处理函数、比较函...
Go-kmeansGo的现成即可使用Kmeans算法包
08-14
kmeans，Go的现成即可使用Kmeans算法包
go算法库封装
菜鸟的博客
01-22 1683
封装go算法库，风格上与Java类似，方便开发，同时封入了环签名、盲签名，里面有Test Demo使用方法，QQ：529832517 https://github.com/xujiamingtxwd123/alg-api
go 简单封装数学运算包
牛奔的博客
05-13 212
前言 我们在编写程序时，经常会遇到一些高精度的数学运算，这时候使用简单的运算符会造成精度的缺失。 这里引用了这个第三方包 https://github.com/shopspring/decimal 做了下简单的封装 封装 package util import ( "math/rand" "github.com/shopspring/decimal" ) // 判断一个数是否为双数 f...
【Golang星辰图】Go语言数据结构和算法实战：6个常用库详解与应用场景
记录我的学习历程
03-14 1235
本文主要介绍了Go语言中几个常用的数据结构和算法库，包括container、go-datastructures、go-algorithm、go-sort、go-graph和go-search。这些库提供了丰富的数据结构和算法，如列表、集合、映射、栈、队列、优先队列、并查集、搜索算法、排序算法、图算法等。通过详细的使用方法和实例代码，您可以快速上手这些库，实现自己的数据结构和算法项目。
【愚公系列】软考中级-软件设计师 022-数据结构（排序算法）
热门推荐
时光隧道
01-09 2万+
常见的排序算法有以下几种：冒泡排序（Bubble Sort）：依次比较相邻的两个元素，将较大的元素交换到后面，每一轮比较都将最大的元素放到最后。时间复杂度为O(n^2)。选择排序（Selection Sort）：每次从待排序的元素中选取最小的元素，放置在已排序的末尾。时间复杂度为O(n^2)。插入排序（Insertion Sort）：将待排序的元素插入到已排序的序列中的适当位置，使得插入后仍然有序。时间复杂度平均为O(n2)，最好情况下为O(n)，最坏情况下为O(n2)。
Go-Golang算法和数据结构
08-14
Golang算法和数据结构
Go-包goraph实现了图数据结构和算法
08-13
goraph - 一个纯Go图论库(数据结构，算法可视化)
Go-go-algorithms-使用golang实现不同的算法和数据结构
08-14
go-algorithms - 使用golang实现不同的算法和数据结构
golang实现的数据结构与算法
07-17
golang实现的数据结构与算法
go专业数据结构与算法
06-16
本节为go专业数据结构与算法，主要讲解go中的数据结构以及相关的算法，如排序算法等。
GoLang学习笔记之进阶编程（四）：标准库常用包
qq_41736299的博客
12-15 644
GO语言标准库为我们封装了许多常用的方法，我将在本章节简要记录几个常用 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 GO语言标准库为我们封装了许多常用的方法，我将在本章节简要记录几个常用包的使用。包括sort、time、flag、与net/http包的简单使用。 一、Sort包的基本使用 sort包为我们提供了Sort接口，任何数据类型只要满足了Sort接口的以下三种方法，即可调用sort包的函数...
Golang-Json标准包
code_or_code
03-14 1631
Json Tag的妙用(-、omitempty、string、number） package golang import ( "encoding/json" "fmt" "log" "testing" ) type Product struct { Name string `json:"name"` Desc stri...
golang template: “xxx.html“ is an incomplete or empty template 解决方法
05-15 140
这个异常一般是因为在使用 template.New("xxx.html") 时这里的名称非真实存在的视图文件名导致， 这个地方有点坑， 明明ParseFiles函数已经指定了视图路径了，而这里的New里面的名字居然还必须是你后面指定的视图路径中的文件名！
Golang：二进制数据的Base64编码和解码操作
最新发布
彭世瑜的博客
05-17 168
Base64可以将二进制数据编码为文本数据，比如将二进制格式的图片编码为文本存储。前面的部分，是存储了二进制数据的格式，并非base64编码后的结果。这个文本格式可以在浏览器中直接打开。
Go 语言IO操作(文件&文件内容增、删、改、查、复制。。。)
qq_39335595的博客
05-14 1031
O_RDONLY: 以只读方式打开文件。文件指针可定位于文件的任意位置。当尝试写入时，会返回错误。O_WRONLY: 以只写方式打开文件。即使文件已存在，它也会被截断为零长度，除非同时使用了O_APPEND标志。文件指针总是在文件的开始位置。O_RDWR: 以读写方式打开文件。文件指针可定位于文件的任意位置。同时具有读写能力。O_APPEND: 设置文件指针于文件末尾。所有写入操作都会在文件末尾添加数据，而不是覆盖现有内容。O_CREATE: 如果文件不存在，则创建一个新文件。与O_TRUNC。
【go从入门到精通】使用 pprof 在 Go 中进行分析
网易搬砖选手
05-14 334
当你看到有reflect.unsafe_NewArray的时候，你要小心，这里可能存在一些内存泄露或者不安全的使用方式， 我们可以使用traces reflect.unsafe_NewArray来查看使用的地方都有哪些.越大的盒子总是会对应它的使用情况，无论是CPU、内存等，所以在上面的例子中，我们看到的。通过此基本设置，在运行应用程序时，pprof 将公开您可以与之交互的端点，以开始收集应用程序上的配置文件。命令显示特定函数的配置文件数据摘要，包括其消耗的总 CPU 时间的百分比以及调用的次数。
Golang开发：编写测试用例
arslan-robot
05-15 431
在Go语言中，编写测试用例是一种很好的实践，用于确保代码的正确性和可维护性。Go提供了一个内建的testing包，它提供了编写和运行测试用例的基础功能。当你运行go test命令时，Go会查找当前包中所有以Test开头且接收一个*testing.T参数的函数，并将它们作为测试用例运行。每个测试用例都会在一个新的goroutine中执行，因此它们是并发的。如果测试用例中的任何t.Errorf被调用，那么该测试用例将失败，并且错误消息将被打印出来。你可以使用t.Log。
golang数据结构 github
07-28
回答: 在Github上，有一些非常受欢迎的Golang数据结构的仓库。其中一个是gorm，它是一个非常棒的ORM库，旨在提供开发者友好的接口。你可以在GitHub上找到它的地址：GitHub - go-gorm/gorm。\[1\] 另一个推荐的仓库...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值