数据结构STL——golang实现链表list

最新推荐文章于 2023-06-21 12:22:15 发布
最新推荐文章于 2023-06-21 12:22:15 发布
阅读量414 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l2975/article/details/122146450
版权

github仓库存储地址：https://github.com/hlccd/goSTL

概述

​ 链表（list），是一种离散的线性结构，它是又多个分布在不同物理空间的结点，通过指针链接建立逻辑连接而形成的线性结构。

​ 由于它的一个个结点相互之间是分离开的，所以它增加和删除结点的过程就会变得十分简单，只需要找到对应节点并将其增加/删除即可，同时修改该结点前后结点的指针以保证整个链表不断开即可，对整个链表的大多数元素来说几乎没有影响，适用于频繁增删的情况，但它也会频繁的分配空间。

原理

​ 对于一个线性结构来说，主要是要建立其它的连接，相比较于用数组的形式实现来说，数组实现需要分配一段连续的空间用以存储数据，但当数组分配的空间不足时，则需要再重新分配空间并将原有的元素复制过去，考虑到复制数据的时间开销也是不容忽略的，所以需要找到另一个结构去尽量减少复制元素的时间开销。

​ 对此，可以选择使用链表，它是将多个分离的点通过指针连接起来，对于增删元素都只需要修改对应的结点和它前后连接的结点即可，对于链表中存储的其他结点不需要做修改，即可以极大的省去频繁复制元素的时间开销，但相应的，由于每个结点是离散的，每次增删结点都需要分配空间，增加了分配空间的时间开销。

​ 链表和数组两种数据结构各有千秋，当在需要承载的元素过多的时候，可以选择使用链表以减少频繁复制的时间开销，当元素不多时可以选择之间分配一个较大的数组去存储以减少分配空间的时间开销。

添加策略

​ 对于链表来说，由于它的结点之间的物理间隔并不是连续的，而是根据需要随机的分布在整个内存中的，同时，对于一个链表来说，核心的主要是它的首尾结点，可以通过首尾结点进行元素的添加，添加时需要先遍历到对应的位置再进行添加，可以根据位置和总承载元素的情况选择从前或从后进行遍历以减少时间开销。

​ list添加主要会有以下四种情况：

  1. 链表不存在：创建新的结点设为头尾结点即可
  2. 添加在首部：从头结点添加并修改链表的头结点即可
  3. 添加在尾部：从尾结点添加并修改链表的尾结点即可
  4. 添加的中部：从最近的首尾结点开始遍历找到对应位置后插入即可，同时要修改前后结点之间的指针以指向自身，保持链表的连续性。
删除策略

​ 同添加策略一样，链表的删除特性和添加是类似的，只需要删除一个结点即可，同时修改前后连接结点的指针以保证链表的连续性，当删除的是头尾结点时在修改记录的头尾结点即可。当所有元素删除完毕后，需要销毁链表。

​ list删除主要会有以下五种情况：

  1. 链表不存在：结束
  2. 删除首结点：将首节点设为首节点的下一结点，同时销毁首结点
  3. 删除尾结点：将尾节点设为尾节点的上一结点，同时销毁尾结点
  4. 删除中间结点：从最近的首尾结点开始遍历找到对应位置后删除即可，同时将前后结点连接起来，以保证链表的连续性。
  5. 删除后链表中不存在元素：销毁链表

实现

​ list链表结构体，包含链表的头尾节点指针，当增删结点时只需要找到对应位置进行操作即可，当一个节点进行增删时需要同步修改其临接结点的前后指针，结构体中记录整个链表的首尾指针,同时记录其当前已承载的元素，使用并发控制锁以保证数据一致性。

type list struct {
	first *node      //链表首节点指针
	last  *node      //链表尾节点指针
	size  uint64     //当前存储的元素个数
	mutex sync.Mutex //并发控制锁
}

​ 链表的node节点结构体，pre和next是该节点的前后两个节点的指针，用以保证链表整体是相连的。

type node struct {
   data interface{} //结点所承载的元素
   pre  *node       //前结点指针
   next *node       //后结点指针
}
接口
type lister interface {
	Iterator() (i *Iterator.Iterator)                              //创建一个包含链表中所有元素的迭代器并返回其指针
	Sort(Cmp ...comparator.Comparator)                             //将链表中所承载的所有元素进行排序
	Size() (size uint64)                                           //返回链表所承载的元素个数
	Clear()                                                        //清空该链表
	Empty() (b bool)                                               //判断该链表是否位空
	Insert(idx uint64, e interface{})                              //向链表的idx位(下标从0开始)插入元素组e
	Erase(idx uint64)                                              //删除第idx位的元素(下标从0开始)
	Get(idx uint64) (e interface{})                                //获得下标为idx的元素
	Set(idx uint64, e interface{})                                 //在下标为idx的位置上放置元素e
	IndexOf(e interface{}, Equ ...comparator.Equaler) (idx uint64) //返回和元素e相同的第一个下标
	SubList(begin, num uint64) (newList *list)                     //从begin开始复制最多num个元素以形成新的链表
}

type noder interface {
	preNode() (m *node)     //返回前结点指针
	nextNode() (m *node)    //返回后结点指针
	insertPre(pre *node)    //在该结点前插入结点并建立连接
	insertNext(next *node)  //在该结点后插入结点并建立连接
	erase()                 //删除该结点,并使该结点前后两结点建立连接
	value() (e interface{}) //返回该结点所承载的元素
	setValue(e interface{}) //修改该结点承载元素为e
}
New

​ 新建一个list链表容器并返回，初始链表首尾节点为nil，初始size为0。

func New() (l *list) {
	return &list{
		first: nil,
		last:  nil,
		size:  0,
		mutex: sync.Mutex{},
	}
}

​ 新建一个结点并返回其指针， 初始首结点的前后结点指针都为nil。

func newNode(e interface{}) (n *node) {
   return &node{
      data: e,
      pre:  nil,
      next: nil,
   }
}
Iterator

​ 以list链表容器做接收者，将list链表容器中所承载的元素放入迭代器中。

func (l *list) Iterator() (i *Iterator.Iterator) {
	if l == nil {
		l = New()
	}
	l.mutex.Lock()
	//将所有元素复制出来放入迭代器中
	tmp := make([]interface{}, l.size, l.size)
	for n, idx := l.first, uint64(0); n != nil && idx < l.size; n, idx = n.nextNode(), idx+1 {
		tmp[idx] = n.value()
	}
	i = Iterator.New(&tmp)
	l.mutex.Unlock()
	return i
}

​ 以node结点做接收者，返回该结点的前结点。

func (n *node) preNode() (pre *node) {
   if n == nil {
      return
   }
   return n.pre
}

​ 以node结点做接收者，返回该结点的后结点。

func (n *node) nextNode() (next *node) {
   if n == nil {
      return
   }
   return n.next
}
Sort

​ 以list链表容器做接收者，将list链表容器中所承载的元素利用比较器进行排序，可以自行传入比较函数,否则将调用默认比较函数。

func (l *list) Sort(Cmp ...comparator.Comparator) {
	if l == nil {
		l = New()
	}
	l.mutex.Lock()
	//将所有元素复制出来用于排序
	tmp := make([]interface{}, l.size, l.size)
	for n, idx := l.first, uint64(0); n != nil && idx < l.size; n, idx = n.nextNode(), idx+1 {
		tmp[idx] = n.value()
	}
	if len(Cmp) > 0 {
		comparator.Sort(&tmp, Cmp[0])
	} else {
		comparator.Sort(&tmp)
	}
	//将排序结果再放入链表中
	for n, idx := l.first, uint64(0); n != nil && idx < l.size; n, idx = n.nextNode(), idx+1 {
		n.setValue(tmp[idx])
	}
	l.mutex.Unlock()
}
Size

​ 以list链表容器做接收者，返回该容器当前含有元素的数量。

func (l *list) Size() (size uint64) {
	if l == nil {
		l = New()
	}
	return l.size
}
Clear

​ 以list链表容器做接收者，将该容器中所承载的元素清空，将该容器的首尾指针均置nil,将size重置为0。

func (l *list) Clear() {
	if l == nil {
		l = New()
	}
	l.mutex.Lock()
	//销毁链表
	l.first = nil
	l.last = nil
	l.size = 0
	l.mutex.Unlock()
}
Empty

​ 以list链表容器做接收者，判断该list链表容器是否含有元素，如果含有元素则不为空,返回false，如果不含有元素则说明为空,返回true，如果容器不存在,返回true，该判断过程通过size进行判断,为0则为true,否则为false。

func (l *list) Empty() (b bool) {
	if l == nil {
		l = New()
	}
	return l.size == 0
}
Insert

​ 以list链表容器做接收者，通过链表的首尾结点进行元素插入，插入的元素可以有很多个，通过判断idx。

func (l *list) Insert(idx uint64, e interface{}) {
	if l == nil {
		l = New()
	}
	l.mutex.Lock()
	n := newNode(e)
	if l.size == 0 {
		//链表中原本无元素,新建链表
		l.first = n
		l.last = n
	} else {
		//链表中存在元素
		if idx == 0 {
			//插入头节点
			n.insertNext(l.first)
			l.first = n
		} else if idx >= l.size {
			//插入尾节点
			l.last.insertNext(n)
			l.last = n
		} else {
			//插入中间节点
			//根据插入的位置选择从前或从后寻找
			if idx < l.size/2 {
				//从首节点开始遍历寻找
				m := l.first
				for i := uint64(0); i < idx-1; i++ {
					m = m.nextNode()
				}
				m.insertNext(n)
			} else {
				//从尾节点开始遍历寻找
				m := l.last
				for i := l.size - 1; i > idx; i-- {
					m = m.preNode()
				}
				m.insertPre(n)
			}
		}
	}
	l.size++
	l.mutex.Unlock()
}

​ 以node结点做接收者，对该结点插入前结点，并建立前结点和该结点之间的连接。

func (n *node) insertPre(pre *node) {
   if n == nil || pre == nil {
      return
   }
   pre.next = n
   pre.pre = n.pre
   if n.pre != nil {
      n.pre.next = pre
   }
   n.pre = pre
}

​ 以node结点做接收者，对该结点插入后结点，并建立后结点和该结点之间的连接。

func (n *node) insertNext(next *node) {
   if n == nil || next == nil {
      return
   }
   next.pre = n
   next.next = n.next
   if n.next != nil {
      n.next.pre = next
   }
   n.next = next
}
Erase

​ 以list链表容器做接收者，先判断是否为首尾结点,如果是首尾结点,在删除后将设置新的首尾结点，当链表所承载的元素全部删除后则销毁链表，删除时通过idx与总元素数量选择从前或从后进行遍历以找到对应位置，删除后,将该位置的前后结点连接起来,以保证链表不断裂。

func (l *list) Erase(idx uint64) {
	if l == nil {
		l = New()
	}
	l.mutex.Lock()
	if l.size > 0 && idx < l.size {
		//链表中存在元素,且要删除的点在范围内
		if idx == 0 {
			//删除头节点
			l.first = l.first.next
		} else if idx == l.size-1 {
			//删除尾节点
			l.last = l.last.pre
		} else {
			//删除中间节点
			//根据删除的位置选择从前或从后寻找
			if idx < l.size/2 {
				//从首节点开始遍历寻找
				m := l.first
				for i := uint64(0); i < idx; i++ {
					m = m.nextNode()
				}
				m.erase()
			} else {
				//从尾节点开始遍历寻找
				m := l.last
				for i := l.size - 1; i > idx; i-- {
					m = m.preNode()
				}
				m.erase()
			}
		}
		l.size--
		if l.size == 0 {
			//所有节点都被删除,销毁链表
			l.first = nil
			l.last = nil
		}
	}
	l.mutex.Unlock()
}

​ 以node结点做接收者，销毁该结点，同时建立该节点前后节点之间的连接。

func (n *node) erase() {
   if n == nil {
      return
   }
   if n.pre == nil && n.next == nil {
      return
   } else if n.pre == nil {
      n.next.pre = nil
   } else if n.next == nil {
      n.pre.next = nil
   } else {
      n.pre.next = n.next
      n.next.pre = n.pre
   }
   n = nil
}
Get

​ 以list链表容器做接收者，获取第idx位结点所承载的元素,若不在链表范围内则返回nil

func (l *list) Get(idx uint64) (e interface{}) {
	if l == nil {
		l = New()
	}
	if idx >= l.size {
		return nil
	}
	l.mutex.Lock()
	if idx < l.size/2 {
		//从首节点开始遍历寻找
		m := l.first
		for i := uint64(0); i < idx; i++ {
			m = m.nextNode()
		}
		e = m.value()
	} else {
		//从尾节点开始遍历寻找
		m := l.last
		for i := l.size - 1; i > idx; i-- {
			m = m.preNode()
		}
		e = m.value()
	}
	l.mutex.Unlock()
	return e
}

​ 以node结点做接收者，返回该结点所要承载的元素。

func (n *node) value() (e interface{}) {
   if n == nil {
      return nil
   }
   return n.data
}
Set

​ 以list链表容器做接收者，修改第idx为结点所承载的元素,超出范围则不修改。

func (l *list) Set(idx uint64, e interface{}) {
	if l == nil {
		l = New()
	}
	if idx >= l.size {
		return
	}
	l.mutex.Lock()
	if idx < l.size/2 {
		//从首节点开始遍历寻找
		m := l.first
		for i := uint64(0); i < idx; i++ {
			m = m.nextNode()
		}
		m.setValue(e)
	} else {
		//从尾节点开始遍历寻找
		m := l.last
		for i := l.size - 1; i > idx; i-- {
			m = m.preNode()
		}
		m.setValue(e)
	}
	l.mutex.Unlock()
}

​ 以node结点做接收者，对该结点设置其承载的元素。

func (n *node) setValue(e interface{}) {
   if n == nil {
      return
   }
   n.data = e
}
IndexOf

​ 以list链表容器做接收者，返回与e相同的元素的首个位置，可以自行传入用于判断相等的相等器进行处理，遍历从头至尾,如果不存在则返回l.size。

func (l *list) IndexOf(e interface{}, Equ ...comparator.Equaler) (idx uint64) {
	if l == nil {
		l = New()
	}
	l.mutex.Lock()
	var equ comparator.Equaler
	if len(Equ) > 0 {
		equ = Equ[0]
	} else {
		equ = comparator.GetEqual()
	}
	n := l.first
	//从头寻找直到找到相等的两个元素即可返回
	for idx = 0; idx < l.size && n != nil; idx++ {
		if equ(n.value(), e) {
			break
		}
		n = n.nextNode()
	}
	l.mutex.Unlock()
	return idx
}
SubList

​ 以list链表容器做接收者，以begin为起点(包含),最多复制num个元素进入新链表，并返回新链表指针。

func (l *list) SubList(begin, num uint64) (newList *list) {
	if l == nil {
		l = New()
	}
	newList = New()
	l.mutex.Lock()
	if begin < l.size {
		//起点在范围内,可以复制
		n := l.first
		for i := uint64(0); i < begin; i++ {
			n = n.nextNode()
		}
		m := newNode(n.value())
		newList.first = m
		newList.size++
		for i := uint64(0); i < num-1 && i+begin < l.size-1; i++ {
			n = n.nextNode()
			m.insertNext(newNode(n.value()))
			m = m.nextNode()
			newList.size++
		}
		newList.last = m
	}
	l.mutex.Unlock()
	return newList
}

使用示例

package main

import (
	"fmt"
	"github.com/hlccd/goSTL/data_structure/list"
	"sync"
)

func main() {
	l := list.New()
	wg := sync.WaitGroup{}
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(idx uint64) {
			l.Insert(idx, idx)
			wg.Done()
		}(uint64(i))
	}
	wg.Wait()
	fmt.Println("使用迭代器访问全部元素；")
	for i := l.Iterator(); i.HasNext(); i.Next() {
		fmt.Println(i.Value())
	}
	l.Set(5, "测试")
	fmt.Println("输出刚设定的测试元素的位置：", l.IndexOf("测试"))
	fmt.Println("从测试位生产新list，长度上限为10，并从头部输出：")
	newList := l.SubList(l.IndexOf("测试"), 10)
	len := newList.Size()
	fmt.Println("新链表的长度：", len)
	for i := uint64(0); i < len; i++ {
		fmt.Println(newList.Get(0))
		newList.Erase(0)
	}
	fmt.Println("从结尾向首部输出原链表：")
	for i := l.Size(); i > 0; i-- {
		fmt.Println(l.Get(i - 1))
		l.Erase(i - 1)
	}
}

注：由于过程中的增删过程是并发执行的，所以其结果和下方示例并不完全相同

使用迭代器访问全部元素；
0
1
2
3
4
5
6
7
9
8
输出刚设定的测试元素的位置： 5
从测试位生产新list，长度上限为10，并从头部输出：
新链表的长度： 5
测试
6
7
9
8
从结尾向首部输出原链表：
8
9
7
6
测试
4
3
2
1
0

hlccd
关注
专栏目录
Go基础：数据结构（定义和go语言实现）
林钟一的博客
03-16 2272
最近在刷leetcode的每日一题的，总会碰到一些问题，因为竞赛时用惯了c++的STL库，有数据结构的实现，可以直接使用，到现在用go总会遇到头疼的事情就是用到数据结构的时候需要自己定义结构并且实现方法，刚好这几天笔试里面也有关于数据结构的题目，所以这一篇主要来讲一下数据结构。
golang基础（基础包链表使用）
课前的博客
12-05 2677
前言golang版本包中提供了三种数据结构：list、heap和ring。已经golang的基本数据类型map。这4中数据结构算是日常开发中最常用的数据结构了。最常用的应该是map所以，golang才会将其作为基本类型。golang提供的这些数据结构，并没有保证并发安全的情况。所以最好在开发的过程中操作的时候要加锁，避免造成不必要的麻烦。也不用吐槽为什么map抛出一个不能同时读写的error。lis
STL的List链表自行实现
11-04
C++中STL的List链表容器的自行实现，自行实现迭代器、类、封装函数等
数据结构与算法 — 链表常见操作（Golang）
Mr_XiMu的博客
03-13 405
链表 — Golang语言的实现
Golang 链表实现
weixin_44707778的博客
11-28 206
Golang 链表实现 package main //链表实现 import ( "fmt" "os" ) //定义错误常量 const ( ERROR = -1000000001 ) //定义元素类型 type Element int64 //定义节点 type LinkNode struct { Data Element //数据域 Nest *LinkNode //指针域，...
golang实现链表
李三思的博客
07-16 492
golang实现链表
golang 数据库 表 结构体自动生成工具.zip
最新发布
06-16
STL（Standard Template Library）是C++的标准库，其中包含了许多高效的数据结构，如vector、list、set、map等。 - **Java**：Java提供了丰富的内置数据结构，如ArrayList、LinkedList、HashSet、HashMap等，它们...
golang知识图谱
点滴生活
09-06 1675
其他 常用包 常用包 说明 fmt 实现格式化的输入输出操作，其中的fmt.Printf()和fmt.Println()是开发者使用最为频繁的函数。 io 实现了一系列非平台相关的IO相关接口和实现，比如提供了对os中系统相关的IO功能的封装。我们在进行流式读写（比如读写文件）时，通常会用到该包。 bufio 它在io的基础上提供了缓存功能。在具备了缓存功能后， bufio可以比较方便地提供ReadLine之类的操作。 strconv ...
2_数据结构与算法
贵在坚持
01-04 4693
O Master basic algorithoms and design models. KR Master sort ,insert and research algorithoms. Master basic algorithoms about others. Master all kinds of data structure. Master common design model. sort ,insert and research algorithoms.
golang数据结构之List
dobe85601的博客
08-10 261
golang数据结构之List,实际中用得很少，这里只做研究。 package main import ( "container/list" "github.com/sanity-io/litter" ) type Thing struct { Id int Info string } // golang 双向链表结构 func main...
STL链表的实现
weixin_45832594的博客
03-11 1099
一，声明链表。 先把今天讲的函数列一下： push_back();//尾部插入元素 push_front();//头部插入元素 pop_back(); //删除尾部元素 reverse();//翻转链表 insert(,);//插入操作 erase(lst1.begin(),lst1.end()); //删除元素 merge()；//链表的合并 begin();//返回首值的迭代器； end()...
Go语言链表实现
码墨
11-25 2426
package linklist import ( &quot;errors&quot; &quot;fmt&quot; ) type ListNode struct { data interface{} next *ListNode } type LinkList struct { head *ListNode length uint } func NewLinkList() *LinkList { retu..
Golang 实现链表类型及相关操作
带着你的名字的博客
10-24 349
Golang 实现链表类型
Go语言实现单链表
m0_53318344的博客
06-21 1471
单链表的操作有创建一个链表通过数组，遍历单链表，尾部插入，指定位置插入，删除指定位置的元素，查找指定的节点等。1.Go语言的语法还是和其他语言不同的，比如函数返回值，参数的定义2.Go语言可以使用vscode，idea goland去编写代码。3.Go语言的命名规则和其他语言也不同，首字母大写表示public，小写表示private。
STL-list实现链表
hpuw1234的博客
08-22 337
vector是一种可以用作动态数组的数据结构，方便好用。 #include用来将STL的vector包含到程序中。 vector  V;是一个声明，用于生成管理double型元素的栈。STL提供的vector是一个模板，需要我们在
golang 的container/list (一)
地球流浪猫的博客
03-29 6761
问题1：有了slice，还要list做什么？ 问题2：list的底层实现是什么？ 带着这两个问题来什么有浅入深的学习golang 语言 。 首先来看官方的解释： 包list 实现 linked list (链表) 而且是双向（doubly）链表。思路顺着双向链表走。 双向链表： 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从...
STL的简单实现(二) 链表
Saber_rem的博客
05-31 475
简单实现了STL的链表主要功能包括访问首尾节点,节点的插入与标记,以及任意起点顺序访问/*  在此此文件或 此文件包含的头文件中定义名为ListNote的结构体 作为数据*/class LIST {private: ListNote *list;  // 浮动点 ListNote *head;   //首节点 ListNote *final;  //尾节点 ListNote *symbol;   ...
模拟STL链表类的实现
rprp1234的博客
08-05 286
模拟STL链表类的实现 STL内部定义了多种容器和迭代器，方便了数据结构类的使用，且不需关注内部源码。为了方便个人使用习惯，我又重写了一个链表类，作为学C++后的第一个项目作业。我将其命名为clist。 代码及注释 /* clist是一个链表类，而_clist是链表的一个单元，iter是一个迭代器（与STL模板库用法相同）。 clist的成员函数： int:
STL list容器：双向链表实现与操作详解
STL的list容器，也称为双向链表容器，其底层实现采用双向链表结构。这种设计允许元素分布在内存的不同位置，无需保持连续的内存布局。图1展示了list容器的存储结构，每个元素都有两个指针：一个指向前一个元素，一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值