数据结构STL——golang实现vector

最新推荐文章于 2024-08-30 08:58:54 发布
最新推荐文章于 2024-08-30 08:58:54 发布
阅读量913 收藏 5
点赞数 2
分类专栏： 数据结构 文章标签： golang 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l2975/article/details/120876958
版权

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

概述

​ 向量（Vector）是一个封装了动态大小数组的顺序容器。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

​ 对于vector的实现,考虑到它是一个线性容器,其中的元素可以通过下标在O(1)的时间复杂度直接获取访问，可以考虑底层使用数组的形式实现。由于vector可以动态的添加和删除元素，所以需要对数组进行动态分配以满足需求。

​ 对于golang语言来说，官方并未设计泛型，但由于interface可以充当任意类型的特性，可以使用interface类型作为泛型类型。

原理

​ 对于一个vector来说，它是可以动态的对元素进行添加和修改的，而如果说每一次增删元素都使得数组恰好可以容纳所有元素的话，那它在以后的每一次增删的过程中都需要去重新分配空间，并将原有的元素复制到新数组中，如果按照这样来操作的话，每次删减都会需要花费大量的时间去进行，将会极大的降低其性能。

​ 为了提高效率，可以选择牺牲一定的空间作为冗余量，即时空权衡，通过每次扩容时多分配一定的空间，这样在后续添加时就可以减少扩容次数，而在删除元素时，如果冗余量不多时，可以选择不进行空间分配，仅将后续元素前移一位，同理，在中间插入元素也仅仅将其后移一位，这样可以极大减少的由于容量不足或超出导致的扩容缩容造成的时间开销。

扩容策略

​ 对于动态数组扩容来说，由于其添加是线性且连续的，即每一次只会增加一个，不像bitmap一样可能需要一次添加很多的空间才能保证在其范围内，所以它的扩容策略相对于bitmap有所不同。

​ vector的扩容主要由两种方案：

  1. 固定扩容：固定的去增加一定量的空间，该方案时候在数组较大时添加空间，可以避免直接翻倍导致的冗余过量问题，到由于增加量是固定的，如果需要一次扩容很多量的话就会比较缓慢。
  2. 翻倍扩容：将原有容量直接翻倍，该方案适合在数组不太大的适合添加空间，可以提高扩容量，增加扩容效率，但数组太大时使用的话会导致一次性增加太多空间，进而造成空间的浪费。
缩容策略

​ 对于动态数组的缩容来说，同扩容类似，由于元素的减少只会是线性且连续的，即每一次只会减少一个，不会存在由于一个元素被删去导致其他已使用的空间也需要被释放。所以vector的缩容方案和vector的扩容方案十分类似，即是它的逆过程：

  1. 固定缩容：释放一个固定的空间，该方案适合在当前数组较大的时候进行，可以减缓需要缩小的量，当空间较大的时候如果采取折半缩减的话;将可能在绝大多数时间内都不会被采用，从而造成空间浪费。
  2. 折半缩容：将当前容量进行折半，该方案适合数组不太大的适合进行缩容，可以更快的缩小容量，但对于较大的空间来说并不会频繁使用到。

实现

​ 由于vector底层由动态数组实现，所以其必然包含一个数组指针，同时，利用时空权衡去减少时间开销导致实际使用空间和实际占用空间不一致，所以分别利用len和cap进行存储。同时，为了解决在高并发情况下的数据不一致问题，引入了并发控制锁。

type vector struct {
   data  []interface{} //动态数组
   len   uint64        //当前已用数量
   cap   uint64        //可容纳元素数量
   mutex sync.Mutex    //并发控制锁
}
接口
type vectorer interface {
	Iterator() (i *Iterator.Iterator)  //返回一个包含vector所有元素的迭代器
	Sort(Cmp ...comparator.Comparator) //利用比较器对其进行排序
	Size() (num uint64)                //返回vector的长度
	Clear()                            //清空vector
	Empty() (b bool)                   //返回vector是否为空,为空则返回true反之返回false
	PushBack(e interface{})            //向vector末尾插入一个元素
	PopBack()                          //弹出vector末尾元素
	Insert(idx uint64, e interface{})  //向vector第idx的位置插入元素e,同时idx后的其他元素向后退一位
	Erase(idx uint64)                  //删除vector的第idx个元素
	Reverse()                          //逆转vector中的数据顺序
	At(idx uint64) (e interface{})     //返回vector的第idx的元素
	Front() (e interface{})            //返回vector的第一个元素
	Back() (e interface{})             //返回vector的最后一个元素
}
New

​ 创建一个vector容器并初始化，同时返回其指针。

func New() (v *vector) {
	return &vector{
		data:  make([]interface{}, 1, 1),
		len:   0,
		cap:   1,
		mutex: sync.Mutex{},
	}
}
Iterator

​ 以vector为接受器，返回一个包含vector中所有元素的迭代器，同时将vector中暂未使用的空间进行释放。

func (v *vector) Iterator() (i *Iterator.Iterator) {
	if v == nil {
		v = New()
	}
	v.mutex.Lock()
	if v.data == nil {
		//data不存在,新建一个
		v.data = make([]interface{}, 1, 1)
		v.len = 0
		v.cap = 1
	} else if v.len < v.cap {
		//释放未使用的空间
		tmp := make([]interface{}, v.len, v.len)
		copy(tmp, v.data)
		v.data = tmp
	}
	//创建迭代器
	i = Iterator.New(&v.data)
	v.mutex.Unlock()
	return i
}
Sort

​ 以vector为接受器，重载了比较器中的Sort，实现了让vector利用比较器中的Sort进行排序，使用过程中将会释放vector中暂未使用的空间。

func (v *vector) Sort(Cmp ...comparator.Comparator) {
   if v == nil {
      v = New()
   }
   v.mutex.Lock()
   if v.data == nil {
      //data不存在,新建一个
      v.data = make([]interface{}, 1, 1)
      v.len = 0
      v.cap = 1
   } else if v.len < v.cap {
      //释放未使用空间
      tmp := make([]interface{}, v.len, v.len)
      copy(tmp, v.data)
      v.data = tmp
      v.cap = v.len
   }
   //调用比较器的Sort进行排序
   if len(Cmp) == 0 {
      comparator.Sort(&v.data)
   } else {
      comparator.Sort(&v.data, Cmp[0])
   }
   v.mutex.Unlock()
}
Size

​ 返回vector中当前所包含的元素个数，由于其数值必然是非负整数，所以选用了uint64。

func (v *vector) Size() (num uint64) {
   if v == nil {
      v = New()
   }
   return v.len
}
Clear

​ 清空了vector中所承载的所有元素。

func (v *vector) Clear() {
   if v == nil {
      v = New()
   }
   v.mutex.Lock()
   //清空data
   v.data = make([]interface{}, 1, 1)
   v.len = 0
   v.cap = 1
   v.mutex.Unlock()
}
Empty

​ 判断vector中是否为空，通过Size()是否为0进行判断。

func (v *vector) Empty() (b bool) {
   if v == nil {
      v = New()
   }
   return v.Size() <= 0
}
PushBack

​ 以vector为接受器，向vector尾部添加一个元素，添加元素会出现两种情况，第一种是还有冗余量，此时直接覆盖以len为下标指向的位置即可，另一种情况是没有冗余量了，需要对动态数组进行扩容，此时就需要利用扩容策略。

​ 扩容策略上文已做描述，可返回参考，该实现过程种将两者进行了结合使用，可参考下方注释。

​ 固定扩容值设为216，翻倍扩容上限也为216。

func (v *vector) PushBack(e interface{}) {	if v == nil {		v = New()	}	v.mutex.Lock()	if v.len < v.cap {		//还有冗余,直接添加		v.data[v.len] = e	} else {		//冗余不足,需要扩容		if v.cap <= 65536 {			//容量翻倍			if v.cap == 0 {				v.cap = 1			}			v.cap *= 2		} else {			//容量增加2^16			v.cap += 2 ^ 16		}		//复制扩容前的元素		tmp := make([]interface{}, v.cap, v.cap)		copy(tmp, v.data)		v.data = tmp		v.data[v.len] = e	}	v.len++	v.mutex.Unlock()}
PopBack

​ 以vector向量容器做接收者，弹出容器最后一个元素,同时长度–即可，若容器为空,则不进行弹出，当弹出元素后,可能进行缩容，当容量和实际使用差值超过216时,容量直接减去216，否则,当实际使用长度是容量的一半时,进行折半缩容。其缩容策略可参考前方解释。

func (v *vector) PopBack() {   if v == nil {      v = New()   }   if v.Empty() {      return   }   v.mutex.Lock()   v.len--   if v.cap-v.len >= 65536 {      //容量和实际使用差值超过2^16时,容量直接减去2^16      v.cap -= 2 ^ 16      tmp := make([]interface{}, v.cap, v.cap)      copy(tmp, v.data)      v.data = tmp   } else if v.len*2 < v.cap {      //实际使用长度是容量的一半时,进行折半缩容      v.cap /= 2      tmp := make([]interface{}, v.cap, v.cap)      copy(tmp, v.data)      v.data = tmp   }   v.mutex.Unlock()}
Insert

​ 向vector中任意位置插入一个元素，由于其位置必然是非负整数，所以选用了uint64进行表示，同时，当插入位置超出了数组范围时，将在最近的位置进行插入，由于不可能是负数，所以超出范围的情况只有可能是插入下标大于len，此时只需要插入尾部即可，等同于PushBack的操作。

​ 对于插入的下标在范围中时，只需要将后续的一些元素后移一位即可。

​ 是否需要扩容需要在开始进行判断，扩容策略同上。

func (v *vector) Insert(idx uint64, e interface{}) {	if v == nil {		v = New()	}	v.mutex.Lock()	if v.len >= v.cap {		//冗余不足,进行扩容		if v.cap <= 65536 {			//容量翻倍			if v.cap == 0 {				v.cap = 1			}			v.cap *= 2		} else {			//容量增加2^16			v.cap += 2 ^ 16		}		//复制扩容前的元素		tmp := make([]interface{}, v.cap, v.cap)		copy(tmp, v.data)		v.data = tmp	}	//从后往前复制,即将idx后的全部后移一位即可	var p uint64	for p = v.len; p > 0 && p > uint64(idx); p-- {		v.data[p] = v.data[p-1]	}	v.data[p] = e	v.len++	v.mutex.Unlock()}
Erase

​ 删除下标为idx的元素，idx不在数组范围内时，则删除距离其最近的元素，即下标不大于0删除首部，不小于len删除尾部。

​ 删除后进行缩容判断，缩容操作同上方介绍的缩容策略。

func (v *vector) Erase(idx uint64) {   if v == nil {      v = New()   }   if v.Empty() {      return   }   v.mutex.Lock()   for p := idx; p < v.len-1; p++ {      v.data[p] = v.data[p+1]   }   v.len--   if v.cap-v.len >= 65536 {      //容量和实际使用差值超过2^16时,容量直接减去2^16      v.cap -= 2 ^ 16      tmp := make([]interface{}, v.cap, v.cap)      copy(tmp, v.data)      v.data = tmp   } else if v.len*2 < v.cap {      //实际使用长度是容量的一半时,进行折半缩容      v.cap /= 2      tmp := make([]interface{}, v.cap, v.cap)      copy(tmp, v.data)      v.data = tmp   }   v.mutex.Unlock()}
Reverse

​ 以vector为接受器，将vector中所承载的元素逆转，同时，释放掉所有未使用的空间。

func (v *vector) Reverse() {   if v == nil {      v = New()   }   v.mutex.Lock()   if v.data == nil {      //data不存在,新建一个      v.data = make([]interface{}, 1, 1)      v.len = 0      v.cap = 1   } else if v.len < v.cap {      //释放未使用的空间      tmp := make([]interface{}, v.len, v.len)      copy(tmp, v.data)      v.data = tmp      v.cap=v.len   }   for i := uint64(0); i < v.len/2; i++ {      v.data[i], v.data[v.len-i-1] = v.data[v.len-i-1], v.data[i]   }   v.mutex.Unlock()}
At

​ 返回下标为idx的元素，当idx不在数组范围内时返回nil，当idx在范围内时返回对应元素。

func (v *vector) At(idx uint64) (e interface{}) {   if v == nil {      v=New()      return nil   }   v.mutex.Lock()   if idx < 0 && idx >= v.Size() {      v.mutex.Unlock()      return nil   }   if v.Size() > 0 {      e = v.data[idx]      v.mutex.Unlock()      return e   }   v.mutex.Unlock()   return nil}
Front

​ 以vector为接受器，返回vector所承载的元素中位于首部的元素，如果vector为nil或者元素数组为nil或为空，则返回nil。

func (v *vector) Front() (e interface{}) {   if v == nil {      v=New()      return nil   }   v.mutex.Lock()   if v.Size() > 0 {      e = v.data[0]      v.mutex.Unlock()      return e   }   v.mutex.Unlock()   return nil}
Back

​ 以vector为接受器，返回vector所承载的元素中位于尾部的元素，如果vector为nil或者元素数组为nil或为空，则返回nil。

func (v *vector) Back() (e interface{}) {	if v == nil {		v=New()		return nil	}	v.mutex.Lock()	if v.Size() > 0 {		e = v.data[v.len-1]		v.mutex.Unlock()		return e	}	v.mutex.Unlock()	return nil}

使用示例

package mainimport (   "fmt"   "github.com/hlccd/goSTL/data_structure/vector"   "sync")func main() {   v:=vector.New()   wg:=sync.WaitGroup{}   for i:=0;i<10;i++{      wg.Add(1)      go func(num int) {         v.PushBack(num)         v.Insert(uint64(num),num)         wg.Done()      }(i)   }   wg.Wait()   fmt.Println("随机插入后的结果:")   for i := v.Iterator(); i.HasNext(); i.Next() {      fmt.Println(i.Value())   }   v.Sort()   fmt.Println("排序后的结果:")   for i := v.Iterator(); i.HasNext(); i.Next() {      fmt.Println(i.Value())   }   fmt.Println("随机删除一半的结果:")   for i:=0;i<5;i++{      wg.Add(1)      go func(num int) {         v.PopBack()         v.Erase(uint64(i))         wg.Wait()      }(i)   }   wg.Done()   for i:=uint64(0); i<v.Size(); i++ {      fmt.Println(v.At(i))   }   fmt.Println("逆转后的结果:")   v.Reverse()   for i:=uint64(0); i<v.Size(); i++ {      fmt.Println(v.At(i))   }   fmt.Println("在下标5处插入元素-1的结果:")   v.Insert(5,-1)   for i:=uint64(0); i<v.Size(); i++ {      fmt.Println(v.At(i))   }   fmt.Println("首元素:",v.Front())   fmt.Println("尾元素:",v.Back())}

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

随机插入后的结果:
0
1
0
2
3
5
6
7
4
8
1
9
2
3
4
5
6
9
8
7
排序后的结果:
0
0
1
1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
9
随机删除一半的结果:
0
0
1
3
3
5
5
6
6
7
逆转后的结果:
7
6
6
5
5
3
3
1
0
0
在下标5处插入元素-1的结果:
7
6
6
5
5
-1
3
3
1
0
0
首元素: 7
尾元素: 0

hlccd
关注
专栏目录
手把手golang教程——数组与切片
TechFlow的博客
05-17 478
本文始发于个人公众号：TechFlow，原创不易，求个关注 今天是golang专题的第五篇，这一篇我们将会了解golang中的数组和切片的使用。 数组与切片 golang当中数组和C++中的定义类似，除了变量类型写在后面。 比如我们要声明一个长度为10的int型的数组，会写成这样： var a [10]int 数组的长度定义了之后不能改变，这点和C++以及Java是一样的。但是在我们日常使用的过程当中，除非我们非常确定数组长度不会发生变化，否则我们一般不会使用数组，而是使用切片(slice)。 切片
2_数据结构与算法
贵在坚持
01-04 4735
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.
go_vector是基于C ++ std :: Vector的容器数据结构。 go_vector带来了功能编程，并删除了样板代码。-Golang开发
05-26
GoVector版本1.2.0 go_vector是基于C ++ std :: Vector的容器数据结构。 go_vector带来了功能编程，并删除了样板代码。 代码示例*来自文档/ examples / mai GoVector版本1.2.0的片段go_vector是基于C ++ std :: Vector的容器数据结构。 go_vector带来了功能编程，并删除了样板代码。 代码示例*摘自文档/examples/main.go*中的片段*构造一个空的向量var播放器GoVector.Vector播放器= players.Init（）追加一个元素player.PushBack（newPlayer）删除一个元素player.RemoveAt（index）获取元素在索引播放器处At（index）在索引播放器处Set元素.SetAt（index）映射函数pl
golang的vector
sun007700的专栏
11-19 1528
Go语言中使用切片(slice)实现一个Vector容器_weixin_30467087的博客-CSDN博客 package vector import ( "reflect" ) // 小写 只能通过工厂函数创建 type vector struct { values []interface{} } // 创建工厂函数 func New(cap int) *vector { this := new(vector) this.values = make([]in..
GoVector：分布式系统中的时间向量日志库
最新发布
gitblog_00441的博客
08-30 704
GoVector：分布式系统中的时间向量日志库 GoVectorVector clock logging library for Go项目地址:https://gitcode.com/gh_mirrors/go/GoVector 在分布式系统中，事件的顺序对于系统的正确运行至关重要。然而，在没有中心化时钟的情况下，如何准确地记录和排序事件是一个挑战。GoVector，一个用Go语言编写的向量时钟...
Go语言中使用切片(slice)实现一个Vector容器
weixin_30467087的博客
05-23 536
Go语言中的切片(slice)和一些内置函数能实现其他语言容器类Array、Vector的功能，但是Go内置语言包container里只提供了list、heap、ring三种容器，缺少vector容器，在实际的项目中为使用方便有必要包装一个vector，提供vector的常见功能。 C++、Java、C#等语言支持泛型，Go语言不支持泛型，可以用 interface{} 提供类似泛型的...
【Golang 数据结构与法算】 vector 向量
qq_37981903的博客
12-18 874
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
多语言数据结构与算法代码示例集合.zip
C++标准模板库（STL）提供了丰富的数据结构和算法实现，如vector、list、map、set、stack、queue、priority_queue等，以及排序（sort）、搜索（find、lower_bound等）和数值算法。 7. 学习资源的使用方法： 学习者...
Golang的变量常量及基本类型
欧阳冉冉的部落格
02-01 1万+
1,变量变量的声明: Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明， Go语言引入了 关键字var，而类型信息放在变量名之后，示例如下：1.1变量的声明var v1 int var v2 string var v3 [10]int // 数组 var v4 []int // 数组切片 var v5 struct { f int } var v6 *int // 指针 v
Golang优秀开源项目汇总, 10大流行Go语言开源项目, golang 开源项目全集(golang/go/wiki/Projects), GitHub上优秀的Go开源项目...
热门推荐
weixin_33836874的博客
05-08 1万+
  Golang优秀开源项目汇总（持续更新。。。）我把这个汇总放在github上了， 后面更新也会在github上更新。 https://github.com/hackstoic/golang-open-source-projects  。 欢迎fork， star ， watch， 提issue。    资料参考来源：http://studygolang.com/projects 监控...
STL入门：容器类介绍与应用
STL提供了丰富的数据结构和算法，包括容器、迭代器和算法等，能够大大提高程序员的开发效率，并且提供了高性能的实现。 ## 1.1 什么是STL STL是C++标准库的一部分，它主要包括容器（Containers）、算法...
go-vector:用于 go 的简单 2d 矢量库
06-28
去向量 用于 go 的简单 2d 矢量库
Go-golang-set-Go的线程安全的和非线程安全的高性能集
08-14
golang-set - Go的线程安全的和非线程安全的高性能集
math3d:在golang中实现的向量和矩阵运算
05-21
gomath3d 在golang中实现的向量和矩阵运算
[转]使用Go语言一段时间的感受
heiyeluren的blog（黑夜路人的开源世界）
12-23 3221
来源：http://www.open-open.com/news/view/1894f94文/Windstorm有一段时间没更新了。最近在忙一个 Server+Client 的项目，Client 是 Android 手机，大概也就是几十的规模。Server 是纯 Golang 实现，没有 apache 或者 ngix 这种 web server，也没有数据库，自己写了个文件管理 module，ha
Go语言中泛型的使用
shura1014的博客
11-07 187
一个加法运算，整数类型与浮点类型的逻辑都是一样的，就没必要去写两个方法 sumInt sumFloat 在Go 1.18之后也引入了泛型 ...
go 用slice模拟vector功能
sydnash的专栏
02-10 3064
appendVectora = append(a, b...)copyb = append([]T(nil), a...)b = make([]T, len(a)) copy(b, a)cut删除一段范围i~jcopy(a[i:], a[j:]) for k, n := len(a) - j + i, len(a); k < n; k++ { a[k] = nil //or the zero
Go最新使用 Vector 在 Kubernetes 中收集日志_vector日志 +kafka(1)，2024年最新掌握这些知识点再也不怕面试通不过
2401_84926700的博客
05-17 693
但是，在本文中，我们将重点关注 Pod 日志和节点服务日志，因为事件需要额外的软件来抓取它们，这涉及到 Kubernetes API，因此将其扩展到我们的范围之外。它们具有独特的结构，因为它们仅存在于 etcd 中，因此为了收集它们，您必须向 Kubernetes API 发出请求。您可以为聚合器部署专用节点，并在必要时对其进行扩展，从而优化 Vector 在集群节点上的资源消耗。简而言之，Vector 包含一种强大的转换语言，称为矢量重映射语言 （VRL），允许无限数量的可能转换。
C语言实现链表与vector的数据结构教学
该项目的主要特点是使用C语言实现了类似STL（标准模板库）中vector的功能，但它并非使用数组实现，而是采用了带头节点的双向循环链表的数据结构。" 知识点详细说明： 1. C语言数据结构基础：C语言作为一种结构化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值