feat: impl LinkedStack & SyncLinkedStack

Author: CC11001100

stack_linked.go

@@ -1,3 +1,92 @@
 package stack
 
-type LinkedStack[T any] struct{}
+type LinkedStack[T any] struct {
+	top *Node[T]
+}
+
+var _ Stack[any] = &LinkedStack[any]{}
+
+func NewLinkedStack[T any]() *LinkedStack[T] {
+	return &LinkedStack[T]{}
+}
+
+func (x *LinkedStack[T]) Push(values ...T) error {
+	for _, value := range values {
+		node := &Node[T]{
+			value: value,
+		}
+		// 此时栈为空
+		if x.top == nil {
+			x.top = node
+		} else {
+			// 将新的节点指向栈顶，同时把栈顶指针往上移动
+			node.next = x.top
+			x.top = node
+		}
+	}
+	return nil
+}
+
+func (x *LinkedStack[T]) Pop() T {
+	e, _ := x.PopE()
+	return e
+}
+
+func (x *LinkedStack[T]) PopE() (T, error) {
+	if x.top == nil {
+		return nil, ErrStackEmpty
+	}
+	top := x.top
+	x.top = x.top.next
+	top.next = nil
+	top.value = nil
+	value := top.value
+	return value, nil
+}
+
+func (x *LinkedStack[T]) Peek() T {
+	e, _ := x.PeekE()
+	return e
+}
+
+func (x *LinkedStack[T]) PeekE() (T, error) {
+	if x.top == nil {
+		return nil, ErrStackEmpty
+	}
+	return x.top.value, nil
+}
+
+func (x *LinkedStack[T]) IsEmpty() bool {
+	return x.top == nil
+}
+
+func (x *LinkedStack[T]) IsNotEmpty() bool {
+	return x.top != nil
+}
+
+func (x *LinkedStack[T]) Len() int {
+	count := 0
+	node := x.top
+	for node != nil {
+		count++
+		node = node.next
+	}
+	return count
+}
+
+func (x *LinkedStack[T]) Clear() error {
+	x.top = nil
+	return nil
+}
+
+func (x *LinkedStack[T]) String() string {
+	//TODO implement me
+	panic("implement me")
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+type Node[T any] struct {
+	value T
+	next  *Node[T]
+}

stack_linked_sync.go

@@ -1 +1,77 @@
 package stack
+
+import "sync"
+
+type SyncLinkedStack[T any] struct {
+	stack *LinkedStack[T]
+	lock  sync.RWMutex
+}
+
+var _ Stack[any] = &SyncLinkedStack[any]{}
+
+func NewSyncLinkedStack[T any]() *SyncLinkedStack[T] {
+	return &SyncLinkedStack[T]{
+		stack: NewLinkedStack[T](),
+		lock:  sync.RWMutex{},
+	}
+}
+
+func (x *SyncLinkedStack[T]) Push(values ...T) error {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	return x.stack.Push(values...)
+}
+
+func (x *SyncLinkedStack[T]) Pop() T {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	return x.stack.Pop()
+}
+
+func (x *SyncLinkedStack[T]) PopE() (T, error) {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	return x.stack.PopE()
+}
+
+func (x *SyncLinkedStack[T]) Peek() T {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.Peek()
+}
+
+func (x *SyncLinkedStack[T]) PeekE() (T, error) {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.PeekE()
+}
+
+func (x *SyncLinkedStack[T]) IsEmpty() bool {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.IsEmpty()
+}
+
+func (x *SyncLinkedStack[T]) IsNotEmpty() bool {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.IsNotEmpty()
+}
+
+func (x *SyncLinkedStack[T]) Len() int {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.Len()
+}
+
+func (x *SyncLinkedStack[T]) Clear() error {
+	x.lock.Lock()
+	defer x.lock.Unlock()
+	return x.stack.Clear()
+}
+
+func (x *SyncLinkedStack[T]) String() string {
+	x.lock.RLock()
+	defer x.lock.RLock()
+	return x.stack.String()
+}

stack_min.go

@@ -1 +1,3 @@
 package stack
+
+