代码实现
package dataStruct
import (
"errors"
"sync"
)
// GenericQueue 是一个支持泛型的不可重复队列，具有最大长度限制
// T 是泛型参数
type GenericQueue[T comparable] struct {
items map[T]struct{} // 使用 map 来存储元素
order []T // 使用切片来记录元素的顺序
lock sync.RWMutex // 读写锁，保证并发安全
maxSize int // 最大队列长度
}
// NewGenericQueue 创建一个新的泛型队列，并指定最大长度
func NewGenericQueue[T comparable](maxSize int) *GenericQueue[T] {
return &GenericQueue[T]{
items: make(map[T]struct{}), // 初始化 items map
order: []T{}, // 初始化 order 切片
maxSize: maxSize, // 设置最大长度
}
}
// Add 添加元素到队列
// 如果队列已满，默认移除最旧的元素来腾出空间
func (q *GenericQueue[T]) Add(item T) error {
q.lock.Lock() // 加写锁，防止并发修改
defer q.lock.Unlock() // 解锁
// 判断元素是否已经存在
if _, exists := q.items[item]; exists {
return errors.New("item already exists in the queue")
}
// 如果队列已满，移除最旧的元素
if len(q.order) >= q.maxSize {
return errors.New("Out of length Queue ")
}
// 将元素添加到 map 中，标记该元素已存在
q.items[item] = struct{}{}
// 将元素添加到队列顺序中
q.order = append(q.order, item)
return nil
}
// Remove 删除队列中的指定元素
// 如果元素不存在，则返回错误
func (q *GenericQueue[T]) Remove(item T) error {
q.lock.Lock() // 加写锁，防止并发修改
defer q.lock.Unlock() // 解锁
// 判断元素是否存在
if _, exists := q.items[item]; !exists {
return errors.New("item not found in the queue")
}
// 从 map 中删除该元素
delete(q.items, item)
// 从顺序切片中删除该元素
for i, v := range q.order {
if v == item {
q.order = append(q.order[:i], q.order[i+1:]...) // 删除指定位置的元素
break
}
}
return nil
}
// Update 修改队列中的元素
// 如果元素不存在，则返回错误
func (q *GenericQueue[T]) Update(oldItem, newItem T) error {
q.lock.Lock() // 加写锁，防止并发修改
defer q.lock.Unlock() // 解锁
// 判断 oldItem 是否存在
if _, exists := q.items[oldItem]; !exists {
return errors.New("old item not found in the queue")
}
// 判断 newItem 是否已存在
if _, exists := q.items[newItem]; exists {
return errors.New("new item already exists in the queue")
}
// 从 map 中删除 oldItem，并添加 newItem
delete(q.items, oldItem)
q.items[newItem] = struct{}{}
// 更新顺序切片中的 oldItem 为 newItem
for i, v := range q.order {
if v == oldItem {
q.order[i] = newItem
break
}
}
return nil
}
// Contains 查询队列中是否存在指定元素
func (q *GenericQueue[T]) Contains(item T) bool {
q.lock.RLock() // 加读锁，防止并发修改
defer q.lock.RUnlock() // 解锁
_, exists := q.items[item]
return exists
}
// Traverse 遍历队列中的元素
func (q *GenericQueue[T]) Traverse() []T {
q.lock.RLock() // 加读锁，防止并发修改
defer q.lock.RUnlock() // 解锁
// 返回元素的副本，防止并发问题
result := make([]T, len(q.order))
copy(result, q.order)
return result
}
// Iterator 返回一个可以用于 for range 的通道
func (q *GenericQueue[T]) Iterator() <-chan T {
ch := make(chan T)
go func() {
q.lock.RLock() // 加读锁，防止并发修改
defer q.lock.RUnlock() // 解锁
defer close(ch) // 关闭通道
for _, item := range q.order {
ch <- item
}
}()
return ch
}
介绍
1. 支持泛型
- 队列支持泛型参数
T，因此可以存储任何类型的元素，只要该类型是 comparable（可比较的）。这意味着你可以使用这个队列来存储数字、字符串、结构体等类型的数据。
2. 不可重复
- 队列内部通过
map 来存储元素，因此它自动确保元素的唯一性。也就是说，队列中不会有重复的元素。
3. 顺序存储
- 使用切片
order 来记录元素的顺序，保证在遍历时元素的顺序是加入队列时的顺序。
4. 并发安全
- 队列实现了并发控制，使用了
sync.RWMutex 读写锁来保证在多线程环境下的安全操作。多个 goroutine 可以并发地读取队列，或者一个 goroutine 可以安全地修改队列。
5. 常见操作
- 添加元素（Add）: 如果元素已经存在，则无法再次添加；如果队列已满，返回
Out of length Queue 错误，不会自动移除最旧元素 - 删除元素（Remove）: 可以删除队列中的某个元素。
- 更新元素（Update）: 可以将队列中的某个元素更新为新的元素，前提是新元素不存在。
- 检查元素是否存在（Contains）: 查询队列中是否包含某个元素。
- 遍历队列（Traverse）: 返回队列中所有元素的副本，供遍历使用。
- 支持
for range 遍历: 通过 Iterator 方法，队列可以返回一个只读通道，可以直接在 for range 循环中使用。
6. 适用场景
- 适用于需要按顺序处理且确保元素唯一的场景，例如任务队列、事件队列等。
- 适用于并发环境，确保多个操作的安全性。
示例用法：
type Ta struct {
Name string
}
func main() {
impl := test.XueTestingImpl
impl.StartTest()
// 示例：创建一个支持整数的泛型队列
queue := dataStruct.NewGenericQueue[Ta](1024)
queue.Add(Ta{Name: "xzm"})
queue.Add(Ta{Name: "yyds"})
queue.Add(Ta{Name: "id"})
//修改
queue.Update(Ta{Name: "id"}, Ta{Name: "ids"})
//遍历
for ta := range queue.Iterator() {
fmt.Println(ta)
}
//查找
contains := queue.Contains(Ta{
Name: "yyds",
})
//删除
queue.Remove(Ta{
Name: "yyds",
})
fmt.Println(contains)
fmt.Println(queue)
fmt.Println(queue.Traverse())
impl.EndTest()
}
