refactor stack interface

Author: CC11001100

README.md

@@ -49,7 +49,7 @@ go get github.com/CC11001100/go-stack
 ## 入栈
 
 ```
-Push(values ...T) error
+Push(values ...T)
 ```
 
 
@@ -92,7 +92,7 @@ Size() int
 ## 清空栈
 
 ```
-Clear() error
+Clear() 
 ```
 
 

array_stack.go

@@ -21,7 +21,7 @@ func NewArrayStack[T any]() *ArrayStack[T] {
 	}
 }
 
-func (x *ArrayStack[T]) Push(values ...T) error {
+func (x *ArrayStack[T]) Push(values ...T) {
 	for _, value := range values {
 		if x.topIndex < len(x.slice) {
 			x.slice[x.topIndex] = value
@@ -30,7 +30,6 @@ func (x *ArrayStack[T]) Push(values ...T) error {
 		}
 		x.topIndex++
 	}
-	return nil
 }
 
 func (x *ArrayStack[T]) Pop() T {
@@ -73,10 +72,9 @@ func (x *ArrayStack[T]) Size() int {
 	return x.topIndex
 }
 
-func (x *ArrayStack[T]) Clear() error {
+func (x *ArrayStack[T]) Clear()  {
 	x.topIndex = 0
 	x.slice = make([]T, 0)
-	return nil
 }
 
 func (x *ArrayStack[T]) String() string {

array_stack_test.go

@@ -1,54 +1,115 @@
 package stack
 
 import (
+	"fmt"
 	"github.com/stretchr/testify/assert"
 	"testing"
 )
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_Clear(t *testing.T) {
 	stack := NewArrayStack[int]()
 	stack.Push(1)
 	stack.Push(2)
 	assert.Equal(t, 2, stack.Size())
+	stack.Clear()
+	assert.Equal(t, 0, stack.Size())
+}
 
+func ExampleArrayStack_Clear() {
+	stack := NewArrayStack[int]()
+	stack.Push(1)
+	stack.Push(2)
+	fmt.Println(stack.Size())
+	stack.Clear()
+	fmt.Println(stack.Size())
+	// Output:
+	// 2
+	// 0
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_IsEmpty(t *testing.T) {
+	stack := NewArrayStack[int]()
+	assert.Equal(t, stack.IsEmpty(), true)
+	stack.Push(1)
+	assert.Equal(t, stack.IsEmpty(), false)
+}
 
+func ExampleArrayStack_IsEmpty() {
+	stack := NewArrayStack[int]()
+	fmt.Println(stack.IsEmpty())
+	stack.Push(1)
+	fmt.Println(stack.IsEmpty())
+	// Output:
+	// true
+	// false
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_IsNotEmpty(t *testing.T) {
+	stack := NewArrayStack[int]()
+	assert.Equal(t, stack.IsNotEmpty(), false)
+	stack.Push(1)
+	assert.Equal(t, stack.IsEmpty(), true)
+}
 
+func ExampleArrayStack_IsNotEmpty() {
+	stack := NewArrayStack[int]()
+	fmt.Println(stack.IsNotEmpty())
+	stack.Push(1)
+	fmt.Println(stack.IsNotEmpty())
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_Size(t *testing.T) {
 
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_Peek(t *testing.T) {
 
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_PeekE(t *testing.T) {
 
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_Pop(t *testing.T) {
 
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_PopE(t *testing.T) {
 
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_Push(t *testing.T) {
 
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestArrayStack_String(t *testing.T) {
 
 }
 
+// ------------------------------------------------ ---------------------------------------------------------------------
+
 func TestNewArrayStack(t *testing.T) {
 
 }
+
+// ------------------------------------------------ ---------------------------------------------------------------------

linked_stack.go

@@ -1,8 +1,18 @@
 package stack
 
+import (
+	"fmt"
+	"strings"
+)
+
+// LinkedStack 基于链表实现的栈
 type LinkedStack[T any] struct {
+
+	// 始终指向栈顶的节点
 	top *Node[T]
-	ln  int
+
+	// 栈中元素的个数，为了实现O(1)计算栈大小
+	elementCount int
 }
 
 var _ Stack[any] = &LinkedStack[any]{}
@@ -11,47 +21,53 @@ func NewLinkedStack[T any]() *LinkedStack[T] {
 	return &LinkedStack[T]{}
 }
 
-func (x *LinkedStack[T]) Push(values ...T) error {
+func (x *LinkedStack[T]) Push(values ...T) {
 	for _, value := range values {
 		node := &Node[T]{
 			value: value,
 		}
 		// 此时栈为空
 		if x.top == nil {
+			// 直接把栈顶指针指向新的节点就可以了
 			x.top = node
 		} else {
-			// 将新的节点指向栈顶，同时把栈顶指针往上移动
+			// 如果栈不为空，将新的节点的next指向栈顶
 			node.next = x.top
+			// 同时把栈顶指针往上移动，指向这个新的节点
 			x.top = node
 		}
-		x.ln++
+		// 栈中元素个数加1
+		x.elementCount++
 	}
-	return nil
 }
 
 func (x *LinkedStack[T]) Pop() T {
-	e, _ := x.PopE()
-	return e
+	element, _ := x.PopE()
+	return element
 }
 
 func (x *LinkedStack[T]) PopE() (T, error) {
 	if x.top == nil {
 		var zero T
 		return zero, ErrStackEmpty
 	}
+
 	top := x.top
 	x.top = x.top.next
 	value := top.value
+
 	top.next = nil
 	var zero T
 	top.value = zero
-	x.ln--
+
+	x.elementCount--
+
 	return value, nil
 }
 
 func (x *LinkedStack[T]) Peek() T {
-	e, _ := x.PeekE()
-	return e
+	element, _ := x.PeekE()
+	return element
 }
 
 func (x *LinkedStack[T]) PeekE() (T, error) {
@@ -71,23 +87,34 @@ func (x *LinkedStack[T]) IsNotEmpty() bool {
 }
 
 func (x *LinkedStack[T]) Size() int {
-	return x.ln
+	return x.elementCount
 }
 
-func (x *LinkedStack[T]) Clear() error {
+func (x *LinkedStack[T]) Clear() {
 	x.top = nil
-	x.ln = 0
-	return nil
+	x.elementCount = 0
 }
 
 func (x *LinkedStack[T]) String() string {
-	//TODO implement me
-	panic("implement me")
+	sb := strings.Builder{}
+	sb.WriteString("[")
+	currentNode := x.top
+	for currentNode != nil {
+		sb.WriteString(fmt.Sprintf("%#v", currentNode.value))
+		currentNode = currentNode.next
+	}
+	sb.WriteString("]")
+	return sb.String()
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
 
+// Node 用于持有栈中元素的节点
 type Node[T any] struct {
+
+	// 持有的节点
 	value T
-	next  *Node[T]
+
+	// 指向往栈底的下一个节点的，如果为空的话表示当前节点就是栈底了
+	next *Node[T]
 }

linked_stack_test.go

@@ -0,0 +1,63 @@
+package stack
+
+import (
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestLinkedStack_Clear(t *testing.T) {
+
+}
+
+func TestLinkedStack_IsEmpty(t *testing.T) {
+
+}
+
+func TestLinkedStack_IsNotEmpty(t *testing.T) {
+
+}
+
+func TestLinkedStack_Peek(t *testing.T) {
+
+}
+
+func TestLinkedStack_PeekE(t *testing.T) {
+
+}
+
+func TestLinkedStack_Pop(t *testing.T) {
+
+}
+
+func TestLinkedStack_PopE(t *testing.T) {
+
+}
+
+func TestLinkedStack_Push(t *testing.T) {
+
+}
+
+func TestLinkedStack_Size(t *testing.T) {
+
+}
+
+func TestLinkedStack_String(t *testing.T) {
+
+}
+
+// ------------------------------------------------ ---------------------------------------------------------------------
+
+func TestNewLinkedStack(t *testing.T) {
+	stack := NewLinkedStack[int]()
+	assert.NotNil(t, stack)
+}
+
+func ExampleNewLinkedStack() {
+	stack := NewLinkedStack[int]()
+	fmt.Println(stack.String())
+	// Output:
+	// []
+}
+
+// ------------------------------------------------ ---------------------------------------------------------------------

max_stack.go

@@ -14,7 +14,7 @@ func NewMaxStack[T any](comparator Comparator[T]) *MaxStack[T] {
 	}
 }
 
-func (x *MaxStack[T]) Push(values ...T) error {
+func (x *MaxStack[T]) Push(values ...T) {
 	for _, value := range values {
 		node := &MaxNode[T]{
 			value: value,
@@ -29,11 +29,8 @@ func (x *MaxStack[T]) Push(values ...T) error {
 		} else {
 			node.max = value
 		}
-		if err := x.stack.Push(node); err != nil {
-			return err
-		}
+		x.stack.Push(node)
 	}
-	return nil
 }
 
 func (x *MaxStack[T]) Pop() T {
@@ -76,8 +73,8 @@ func (x *MaxStack[T]) Size() int {
 	return x.stack.Size()
 }
 
-func (x *MaxStack[T]) Clear() error {
-	return x.stack.Clear()
+func (x *MaxStack[T]) Clear()  {
+	x.stack.Clear()
 }
 
 func (x *MaxStack[T]) String() string {