feat: impl min stack & max stack & sync

Author: CC11001100

comparator.go

@@ -0,0 +1,3 @@
+package stack
+
+type Comparator[T any] func(a T, b T) int

stack_max.go

@@ -1,3 +1,109 @@
 package stack
 
+type MaxStack[T any] struct {
+	comparator Comparator[T]
+	stack      Stack[*MaxNode[T]]
+}
 
+var _ Stack[any] = &MaxStack[any]{}
+
+func NewMaxStack[T any](comparator Comparator[T]) *MaxStack[T] {
+	return &MaxStack[T]{
+		comparator: comparator,
+		stack:      NewArrayStack[*MaxNode[T]](),
+	}
+}
+
+func (x *MaxStack[T]) Push(values ...T) error {
+	for _, value := range values {
+		node := &MaxNode[T]{
+			value: value,
+		}
+		topNode, err := x.stack.PeekE()
+		if err != nil {
+			// 栈为空，认为最大值是自己
+			node.max = value
+		} else if x.comparator(topNode.max, value) > 0 {
+			// 当前栈顶的元素比较小
+			node.max = topNode.max
+		} else {
+			node.max = value
+		}
+		if err := x.stack.Push(node); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (x *MaxStack[T]) Pop() T {
+	e, _ := x.PopE()
+	return e
+}
+
+func (x *MaxStack[T]) PopE() (T, error) {
+	e, err := x.stack.PopE()
+	if err != nil {
+		return nil, err
+	}
+	return e.value, nil
+}
+
+func (x *MaxStack[T]) Peek() T {
+	e, _ := x.PeekE()
+	return e
+}
+
+func (x *MaxStack[T]) PeekE() (T, error) {
+	e, err := x.stack.PeekE()
+	if err != nil {
+		return nil, err
+	}
+	return e.value, nil
+}
+
+func (x *MaxStack[T]) IsEmpty() bool {
+	return x.stack.IsEmpty()
+}
+
+func (x *MaxStack[T]) IsNotEmpty() bool {
+	return x.stack.IsNotEmpty()
+}
+
+func (x *MaxStack[T]) Len() int {
+	return x.stack.Len()
+}
+
+func (x *MaxStack[T]) Clear() error {
+	return x.stack.Clear()
+}
+
+func (x *MaxStack[T]) String() string {
+	return x.stack.String()
+}
+
+func (x *MaxStack[T]) GetMax() T {
+	e, _ := x.GetMaxE()
+	return e
+}
+
+func (x *MaxStack[T]) GetMaxE() (T, error) {
+	e, err := x.stack.PeekE()
+	if err != nil {
+		return nil, err
+	}
+	return e.max, nil
+}
+
+// ------------------------------------------------ ---------------------------------------------------------------------
+
+type MaxNode[T any] struct {
+
+	// 栈的当前位置的值
+	value T
+
+	// 栈底到当前位置的最大值
+	max T
+}
+
+// ------------------------------------------------ ---------------------------------------------------------------------

stack_max_sync.go

@@ -1 +1,90 @@
 package stack
+
+import "sync"
+
+type SyncMaxStack[T any] struct {
+	stack *MaxStack[T]
+	lock  sync.RWMutex
+}
+
+var _ Stack[any] = &SyncMaxStack[any]{}
+
+func NewSyncMaxStack[T any](comparator Comparator[T]) *SyncMaxStack[T] {
+	return &SyncMaxStack[T]{
+		stack: NewMaxStack[T](comparator),
+		lock:  sync.RWMutex{},
+	}
+}
+
+func (x *SyncMaxStack[T]) Push(values ...T) error {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	return x.stack.Push(values...)
+}
+
+func (x *SyncMaxStack[T]) Pop() T {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	return x.stack.Pop()
+}
+
+func (x *SyncMaxStack[T]) PopE() (T, error) {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	return x.stack.PopE()
+}
+
+func (x *SyncMaxStack[T]) Peek() T {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.Peek()
+}
+
+func (x *SyncMaxStack[T]) PeekE() (T, error) {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.PeekE()
+}
+
+func (x *SyncMaxStack[T]) IsEmpty() bool {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.IsEmpty()
+}
+
+func (x *SyncMaxStack[T]) IsNotEmpty() bool {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.IsNotEmpty()
+}
+
+func (x *SyncMaxStack[T]) Len() int {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.Len()
+}
+
+func (x *SyncMaxStack[T]) Clear() error {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	return x.stack.Clear()
+}
+
+func (x *SyncMaxStack[T]) String() string {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.String()
+}
+
+
+func (x *SyncMaxStack[T]) GetMax() T {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.GetMax()
+}
+
+func (x *SyncMaxStack[T]) GetMaxE() (T, error) {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.GetMaxE()
+}

stack_min.go

@@ -1,3 +1,109 @@
 package stack
 
+type MinStack[T any] struct {
+	comparator Comparator[T]
+	stack      Stack[*MinNode[T]]
+}
 
+var _ Stack[any] = &MinStack[any]{}
+
+func NewMinStack[T any](comparator Comparator[T]) *MinStack[T] {
+	return &MinStack[T]{
+		comparator: comparator,
+		stack:      NewArrayStack[*MinNode[T]](),
+	}
+}
+
+func (x *MinStack[T]) Push(values ...T) error {
+	for _, value := range values {
+		node := &MinNode[T]{
+			value: value,
+		}
+		topNode, err := x.stack.PeekE()
+		if err != nil {
+			// 栈为空，认为最小值是自己
+			node.min = value
+		} else if x.comparator(topNode.min, value) < 0 {
+			// 当前栈顶的元素比较小
+			node.min = topNode.min
+		} else {
+			node.min = value
+		}
+		if err := x.stack.Push(node); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (x *MinStack[T]) Pop() T {
+	e, _ := x.PopE()
+	return e
+}
+
+func (x *MinStack[T]) PopE() (T, error) {
+	e, err := x.stack.PopE()
+	if err != nil {
+		return nil, err
+	}
+	return e.value, nil
+}
+
+func (x *MinStack[T]) Peek() T {
+	e, _ := x.PeekE()
+	return e
+}
+
+func (x *MinStack[T]) PeekE() (T, error) {
+	e, err := x.stack.PeekE()
+	if err != nil {
+		return nil, err
+	}
+	return e.value, nil
+}
+
+func (x *MinStack[T]) IsEmpty() bool {
+	return x.stack.IsEmpty()
+}
+
+func (x *MinStack[T]) IsNotEmpty() bool {
+	return x.stack.IsNotEmpty()
+}
+
+func (x *MinStack[T]) Len() int {
+	return x.stack.Len()
+}
+
+func (x *MinStack[T]) Clear() error {
+	return x.stack.Clear()
+}
+
+func (x *MinStack[T]) String() string {
+	return x.stack.String()
+}
+
+func (x *MinStack[T]) GetMin() T {
+	e, _ := x.GetMinE()
+	return e
+}
+
+func (x *MinStack[T]) GetMinE() (T, error) {
+	e, err := x.stack.PeekE()
+	if err != nil {
+		return nil, err
+	}
+	return e.min, nil
+}
+
+// ------------------------------------------------ ---------------------------------------------------------------------
+
+type MinNode[T any] struct {
+
+	// 栈的当前位置的值
+	value T
+
+	// 栈底到当前位置的最小值
+	min T
+}
+
+// ------------------------------------------------ ---------------------------------------------------------------------