Go?container包的介绍

 更新时间:2022-01-27 14:15:51   作者:佚名   我要评论(0)

目录1.简介2.list2.1数据结构
2.2插入元素3.ring3.1数据结构
4.heap4.1数据结构
1.简介


Container — 容器数据类型:该包实现了三个复

1.简介

Container — 容器数据类型:该包实现了三个复杂的数据结构:堆、链表、环

  • List:Go中对链表的实现,其中List:双向链表,Element:链表中的元素
  • Ring:实现的是一个循环链表,也就是我们俗称的环
  • Heap:Go中对堆的实现

2.list

简单实用:

func main()  {
 // 初始化双向链表
 l := list.New()
 // 链表头插入
 l.PushFront(1)
 // 链表尾插入
 l.PushBack(2)
 l.PushFront(3)
 // 从头开始遍历
 for head := l.Front();head != nil;head = head.Next() {
  fmt.Println(head.Value)
 }
}

方法列表:

type Element
    func (e *Element) Next() *Element                                   // 返回该元素的下一个元素,如果没有下一个元素则返回 nil
    func (e *Element) Prev() *Element                                   // 返回该元素的前一个元素,如果没有前一个元素则返回nil

type List                               
    func New() *List                                                    // 返回一个初始化的list
    func (l *List) Back() *Element                                      // 获取list l的最后一个元素
    func (l *List) Front() *Element                                     // 获取list l的第一个元素
    func (l *List) Init() *List                                         // list l 初始化或者清除 list l
    func (l *List) InsertAfter(v interface{}, mark *Element) *Element   // 在 list l 中元素 mark 之后插入一个值为 v 的元素,并返回该元素,如果 mark 不是list中元素,则 list 不改变
    func (l *List) InsertBefore(v interface{}, mark *Element) *Element  // 在 list l 中元素 mark 之前插入一个值为 v 的元素,并返回该元素,如果 mark 不是list中元素,则 list 不改变
    func (l *List) Len() int                                            // 获取 list l 的长度
    func (l *List) MoveAfter(e, mark *Element)                          // 将元素 e 移动到元素 mark 之后,如果元素e 或者 mark 不属于 list l,或者 e==mark,则 list l 不改变
    func (l *List) MoveBefore(e, mark *Element)                         // 将元素 e 移动到元素 mark 之前,如果元素e 或者 mark 不属于 list l,或者 e==mark,则 list l 不改变
    func (l *List) MoveToBack(e *Element)                               // 将元素 e 移动到 list l 的末尾,如果 e 不属于list l,则list不改变             
    func (l *List) MoveToFront(e *Element)                              // 将元素 e 移动到 list l 的首部,如果 e 不属于list l,则list不改变             
    func (l *List) PushBack(v interface{}) *Element                     // 在 list l 的末尾插入值为 v 的元素,并返回该元素              
    func (l *List) PushBackList(other *List)                            // 在 list l 的尾部插入另外一个 list,其中l 和 other 可以相等               
    func (l *List) PushFront(v interface{}) *Element                    // 在 list l 的首部插入值为 v 的元素,并返回该元素              
    func (l *List) PushFrontList(other *List)                           // 在 list l 的首部插入另外一个 list,其中 l 和 other 可以相等              
    func (l *List) Remove(e *Element) interface{}                       // 如果元素 e 属于list l,将其从 list 中删除,并返回元素 e 的值

2.1数据结构

节点定义:

type Element struct {
 // 后继指针,前向指针
 next, prev *Element

 // 链表指针,属于哪个链表
 list *List

 // 节点value
 Value interface{}
}

双向链表定义:

type List struct {
  // 根元素
 root Element // sentinel list element, only &root, root.prev, and root.next are used
 // 实际节点数量
  len  int     // current list length excluding (this) sentinel element
}

初始化:

// 通过工厂方法返回list指针
func New() *List { return new(List).Init() }

func (l *List) Init() *List {
 l.root.next = &l.root
 l.root.prev = &l.root
 l.len = 0
 return l
}

这里可以看到root节点作为一个根节点,不承担数据,也不是实际的链表节点,节点数量len没算上它,再初始化的时候,root节点会成为一个只有一个节点的环(前后指针都指向自己)

2.2插入元素

头插法:

func (l *List) Front() *Element {
 if l.len == 0 {
  return nil
 }
 return l.root.next
}

func (l *List) PushFront(v interface{}) *Element {
 l.lazyInit()
 return l.insertValue(v, &l.root)
}

尾插法:

func (l *List) Back() *Element {
 if l.len == 0 {
  return nil
 }
 return l.root.prev
}

func (l *List) PushBack(v interface{}) *Element {
 l.lazyInit()
 return l.insertValue(v, l.root.prev)
}

在指定元素后新增元素:

func (l *List) insert(e, at *Element) *Element {
 e.prev = at
 e.next = at.next
 e.prev.next = e
 e.next.prev = e
 e.list = l
 l.len++
 return e
}

这里有个延迟初始化的逻辑:lazyInit,把初始化操作延后,仅在实际需要的时候才进行

func (l *List) lazyInit() {
 if l.root.next == nil {
  l.Init()
 }
}

移除元素:

// remove 从双向链表中移除一个元素e,递减链表的长度,返回该元素e 
func (l *List) remove(e *Element) *Element {
  e.prev.next = e.next
  e.next.prev = e.prev
  e.next = nil // 防止内存泄漏
  e.prev = nil // 防止内存泄漏
  e.list = nil
  l.len --
  return e 
}

3.ring

Go中提供的ring是一个双向的循环链表,与list的区别在于没有表头和表尾,ring表头和表尾相连,构成一个环

使用demo:

func main()  {

 // 初始化3个元素的环,返回头节点
 r := ring.New(3)
 // 给环填充值
 for i := 1;i <= 3;i++{
  r.Value = i
  r = r.Next()
 }
 sum := 0
 // 对环的每个元素进行处理
 r.Do(func(i interface{}) {
  sum = i.(int) + sum
 })
 fmt.Println(sum)
}

方法列表:

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 个元素

3.1数据结构

环节点数据结构:

type Ring struct {
 next, prev *Ring // 前继和后继指针
 Value      interface{} // for use by client; untouched by this library
}

初始化一个环:后继和前继指针都指向自己

func (r *Ring) init() *Ring {
 r.next = r
 r.prev = r
 return r
}

初始化指定数量个节点的环

func New(n int) *Ring {
 if n <= 0 {
  return nil
 }
 r := new(Ring)
 p := r
 for i := 1; i < n; i++ {
  p.next = &Ring{prev: p}
  p = p.next
 }
 p.next = r
 r.prev = p
 return r
}

遍历环,对个元素执行指定操作:

func (r *Ring) Do(f func(interface{})) {
 if r != nil {
  f(r.Value)
  for p := r.Next(); p != r; p = p.next {
   f(p.Value)
  }
 }
}

4.heap

Go中堆使用的数据结构是最小二叉树,即根节点比左边子树和右边子树的所有值都小

使用demo:需要实现Interface接口,go中堆都是实现这个接口,定义了排序,插入和删除方法

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

实现接口:

// An IntHeap is a min-heap of ints.
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{}) {
 // Push and Pop use pointer receivers because they modify the slice's length,
 // not just its contents.
 *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
}

// This example inserts several ints into an IntHeap, checks the minimum,
// and removes them in order of priority.
func Example_intHeap() {
 h := &IntHeap{2, 1, 5}
 heap.Init(h)
 heap.Push(h, 3)
 fmt.Printf("minimum: %d\n", (*h)[0])
 for h.Len() > 0 {
  fmt.Printf("%d ", heap.Pop(h))
 }
 // Output:
 // minimum: 1
 // 1 2 3 5
}

4.1数据结构

上浮:

func Push(h Interface, x interface{}) {
 h.Push(x)
 up(h, h.Len()-1)
}

func up(h Interface, j int) {
 for {
  i := (j - 1) / 2 // parent
  if i == j || !h.Less(j, i) {
   break
  }
  h.Swap(i, j)
  j = i
 }
}

下沉:

func Pop(h Interface) interface{} {
 n := h.Len() - 1
 h.Swap(0, n)
 down(h, 0, n)
 return h.Pop()
}

func down(h Interface, i0, n int) bool {
 i := i0
 for {
  j1 := 2*i + 1
  if j1 >= n || j1 < 0 { // j1 < 0 after int overflow
   break
  }
  j := j1 // left child
  if j2 := j1 + 1; j2 < n && h.Less(j2, j1) {
   j = j2 // = 2*i + 2  // right child
  }
  if !h.Less(j, i) {
   break
  }
  h.Swap(i, j)
  i = j
 }
 return i > i0
}

到此这篇关于Go container包的介绍的文章就介绍到这了,更多相关Go container包内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
  • 解决golang中container/list包中的坑
  • 基于golang中container/list包的用法说明

相关文章

  • Go?container包的介绍

    Go?container包的介绍

    目录1.简介2.list2.1数据结构 2.2插入元素3.ring3.1数据结构 4.heap4.1数据结构 1.简介 Container — 容器数据类型:该包实现了三个复
    2022-01-27
  • Go语言做爬虫状态码返回418的问题解决

    Go语言做爬虫状态码返回418的问题解决

    目录背景原因分析代码部分背景 ?在使用Go语言做爬虫时,使用http.Get(url)去获取网页内容,状态码返回404,Body体为空。 原因分析 ?http
    2022-01-27
  • golang实现数组分割的示例代码

    golang实现数组分割的示例代码

    需求:给定一个数组和一个正整数,要求把数组分割成多个正整数大小的数组,如果不够分,则最后一个数组分到剩余的所有元素。 示例1:
    2022-01-27
  • Go语言参数传递是传值还是传引用

    Go语言参数传递是传值还是传引用

    目录什么是传值(值传递)什么是传引用(引用传递)迷惑Mapchan类型和map、chan都不一样的slice小结对于了解一门语言来说,会关心我们在函数调
    2022-01-27
  • vscode搭建go开发环境案例详解

    vscode搭建go开发环境案例详解

    目录前言一、安装goLang二.配置环境变量三、vscode安装插件四.安装golang依赖五.新建go文件提示:文章写完后,目录可以自动生成,如何生成可
    2022-01-27
  • 浅谈Go1.18中的泛型编程

    浅谈Go1.18中的泛型编程

    目录前言以前的Go泛型泛型是什么Go的泛型泛型函数泛型类型类型集合和接口的差异总结前言 经过这几年的千呼万唤,简洁的Go语言终于在1.18版
    2022-01-27
  • golang强制类型转换和类型断言

    golang强制类型转换和类型断言

    目录1.强制类型转换2.类型断言1.强制类型转换 golang是强类型语言,但是和c++,Java不太一样的是,go中没有隐式类型转换,go中的类型转换只有
    2022-01-27
  • 使用go实现一个超级mini的消息队列的示例代码

    使用go实现一个超级mini的消息队列的示例代码

    目录前言目的设计协议 队列 broker 删除消息 生产者 消费者 启动 总结前言 趁着有空余时间,就想着撸一个mini的生产-消费消息队列
    2022-01-27
  • Go?语言的?:=的具体使用

    Go?语言的?:=的具体使用

    目录1. 单变量 :=2. 多变量 :=3. 小结:=? ?Go 语言中 = 和 := 有什么区别1. 单变量 := Go 语言中新增了一个特殊的运算符:=,这个运算符可
    2022-01-27
  • GO使用socket和channel实现简单控制台聊天室

    GO使用socket和channel实现简单控制台聊天室

    使用socket和channel,实现简单控制台聊天室 这里使用socket和channel,演示在GO中如何编写一个简单网络程序 功能分析 聊天室主要功能:用户
    2022-01-27

最新评论