Go
复制代码
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
}