feat: optimized stack array implementation (#658)

* optimized stack array implementation and modified the unit tests accordingly

* Fixed formatting issues

* fix exported all methods and converted tests to blackbox

* Added generic parameter and fixed package name

---------

Co-authored-by: Rak Laptudirm <[email protected]>

Author: 11-aryan

structure/stack/stack_test.go

@@ -7,23 +7,24 @@
 // author [Milad](https://github.com/miraddo)
 // see stackarray.go, stacklinkedlist.go, stacklinkedlistwithlist.go
 
-package stack
+package stack_test
 
 import (
 	"container/list"
+	"github.com/TheAlgorithms/Go/structure/stack"
 	"reflect"
 	"testing"
 )
 
 // TestStackLinkedList for testing Stack with LinkedList
 func TestStackLinkedList(t *testing.T) {
-	var newStack Stack
+	var newStack stack.Stack
 
-	newStack.push(1)
-	newStack.push(2)
+	newStack.Push(1)
+	newStack.Push(2)
 
 	t.Run("Stack Push", func(t *testing.T) {
-		result := newStack.show()
+		result := newStack.Show()
 		expected := []any{2, 1}
 		for x := range result {
 			if result[x] != expected[x] {
@@ -33,20 +34,20 @@ func TestStackLinkedList(t *testing.T) {
 	})
 
 	t.Run("Stack isEmpty", func(t *testing.T) {
-		if newStack.isEmpty() {
-			t.Error("Stack isEmpty is returned true but expected false", newStack.isEmpty())
+		if newStack.IsEmpty() {
+			t.Error("Stack isEmpty is returned true but expected false", newStack.IsEmpty())
 		}
 
 	})
 
 	t.Run("Stack Length", func(t *testing.T) {
-		if newStack.len() != 2 {
-			t.Error("Stack Length should be 2 but got", newStack.len())
+		if newStack.Length() != 2 {
+			t.Error("Stack Length should be 2 but got", newStack.Length())
 		}
 	})
 
-	newStack.pop()
-	pop := newStack.pop()
+	newStack.Pop()
+	pop := newStack.Pop()
 
 	t.Run("Stack Pop", func(t *testing.T) {
 		if pop != 1 {
@@ -55,74 +56,82 @@ func TestStackLinkedList(t *testing.T) {
 
 	})
 
-	newStack.push(52)
-	newStack.push(23)
-	newStack.push(99)
-	t.Run("Stack Peak", func(t *testing.T) {
-		if newStack.peak() != 99 {
-			t.Error("Stack Peak should return 99 but got ", newStack.peak())
+	newStack.Push(52)
+	newStack.Push(23)
+	newStack.Push(99)
+	t.Run("Stack Peek", func(t *testing.T) {
+		if newStack.Peek() != 99 {
+			t.Error("Stack Peak should return 99 but got ", newStack.Peek())
 		}
 	})
 }
 
 // TestStackArray for testing Stack with Array
 func TestStackArray(t *testing.T) {
+	newStack := stack.NewStack[int]()
 	t.Run("Stack With Array", func(t *testing.T) {
 
-		stackPush(2)
-		stackPush(3)
+		newStack.Push(2)
+		newStack.Push(3)
 
 		t.Run("Stack Push", func(t *testing.T) {
-			if !reflect.DeepEqual([]any{3, 2}, stackArray) {
-				t.Errorf("Stack Push is not work we expected %v but got %v", []any{3, 2}, stackArray)
+			var stackElements []any
+			for i := 0; i < 2; i++ {
+				poppedElement := newStack.Pop()
+				stackElements = append(stackElements, poppedElement)
+			}
+
+			if !reflect.DeepEqual([]any{3, 2}, stackElements) {
+				t.Errorf("Stack Push is not work we expected %v but got %v", []any{3, 2}, newStack)
 			}
+
+			newStack.Push(2)
+			newStack.Push(3)
 		})
 
-		pop := stackPop()
+		pop := newStack.Pop()
 
 		t.Run("Stack Pop", func(t *testing.T) {
-
-			if stackLength() == 2 && pop != 3 {
+			if newStack.Length() == 2 && pop != 3 {
 				t.Errorf("Stack Pop is not work we expected %v but got %v", 3, pop)
 			}
 		})
 
-		stackPush(2)
-		stackPush(83)
+		newStack.Push(2)
+		newStack.Push(83)
 
 		t.Run("Stack Peak", func(t *testing.T) {
-
-			if stackPeak() != 83 {
-				t.Errorf("Stack Peak is not work we expected %v but got %v", 83, stackPeak())
+			if newStack.Peek() != 83 {
+				t.Errorf("Stack Peek is not work we expected %v but got %v", 83, newStack.Peek())
 			}
 		})
 
 		t.Run("Stack Length", func(t *testing.T) {
-			if stackLength() != 3 {
-				t.Errorf("Stack Length is not work we expected %v but got %v", 3, stackLength())
+			if newStack.Length() != 3 {
+				t.Errorf("Stack Length is not work we expected %v but got %v", 3, newStack.Length())
 			}
 		})
 
 		t.Run("Stack Empty", func(t *testing.T) {
-			if stackEmpty() == true {
-				t.Errorf("Stack Empty is not work we expected %v but got %v", false, stackEmpty())
+			if newStack.IsEmpty() == true {
+				t.Errorf("Stack Empty is not work we expected %v but got %v", false, newStack.IsEmpty())
 			}
 
-			stackPop()
-			stackPop()
-			stackPop()
+			newStack.Pop()
+			newStack.Pop()
+			newStack.Pop()
 
-			if stackEmpty() == false {
-				t.Errorf("Stack Empty is not work we expected %v but got %v", true, stackEmpty())
+			if newStack.IsEmpty() == false {
+				t.Errorf("Stack Empty is not work we expected %v but got %v", true, newStack.IsEmpty())
 			}
 		})
 	})
 }
 
 // TestStackLinkedListWithList for testing Stack with Container/List Library (STL)
 func TestStackLinkedListWithList(t *testing.T) {
-	stackList := &SList{
-		stack: list.New(),
+	stackList := &stack.SList{
+		Stack: list.New(),
 	}
 
 	t.Run("Stack Push", func(t *testing.T) {
@@ -147,7 +156,7 @@ func TestStackLinkedListWithList(t *testing.T) {
 
 		stackList.Push(2)
 		stackList.Push(83)
-		peak, _ := stackList.Peak()
+		peak, _ := stackList.Peek()
 		if peak != 83 {
 			t.Errorf("Stack Peak is not work we expected %v but got %v", 83, peak)
 		}
@@ -160,8 +169,8 @@ func TestStackLinkedListWithList(t *testing.T) {
 	})
 
 	t.Run("Stack Empty", func(t *testing.T) {
-		if stackList.Empty() == true {
-			t.Errorf("Stack Empty is not work we expected %v but got %v", false, stackList.Empty())
+		if stackList.IsEmpty() == true {
+			t.Errorf("Stack Empty is not work we expected %v but got %v", false, stackList.IsEmpty())
 		}
 
 		d1, err := stackList.Pop()
@@ -172,8 +181,8 @@ func TestStackLinkedListWithList(t *testing.T) {
 			t.Errorf("got an unexpected error %v, pop1: %v, pop2: %v, pop3: %v", err, d1, d2, d3)
 		}
 
-		if stackList.Empty() == false {
-			t.Errorf("Stack Empty is not work we expected %v but got %v", true, stackList.Empty())
+		if stackList.IsEmpty() == false {
+			t.Errorf("Stack Empty is not work we expected %v but got %v", true, stackList.IsEmpty())
 		}
 	})
 }

structure/stack/stackarray.go

@@ -9,31 +9,47 @@
 
 package stack
 
-var stackArray []any
+type Array[T any] struct {
+	elements []T
+}
+
+// NewStack creates and returns a new stack.
+func NewStack[T any]() *Array[T] {
+	return &Array[T]{}
+}
 
-// stackPush push to first index of array
-func stackPush(n any) {
-	stackArray = append([]any{n}, stackArray...)
+// Push adds an element to the top of the stack.
+func (s *Array[T]) Push(value T) {
+	s.elements = append(s.elements, value)
 }
 
-// stackLength return length of array
-func stackLength() int {
-	return len(stackArray)
+// Size returns the number of elements in the stack.
+func (s *Array[T]) Length() int {
+	return len(s.elements)
 }
 
-// stackPeak return last input of array
-func stackPeak() any {
-	return stackArray[0]
+// Peek returns the top element of the stack without removing it.
+func (s *Array[T]) Peek() T {
+	if s.IsEmpty() {
+		var zeroValue T
+		return zeroValue // Stack is empty
+	}
+	return s.elements[len(s.elements)-1]
 }
 
-// stackEmpty check array is empty or not
-func stackEmpty() bool {
-	return len(stackArray) == 0
+// IsEmpty returns true if the stack is empty, false otherwise.
+func (s *Array[T]) IsEmpty() bool {
+	return len(s.elements) == 0
 }
 
-// stackPop return last input and remove it in array
-func stackPop() any {
-	pop := stackArray[0]
-	stackArray = stackArray[1:]
-	return pop
+// Pop removes and returns the top element from the stack.
+func (s *Array[T]) Pop() T {
+	if s.IsEmpty() {
+		var zeroValue T
+		return zeroValue // Stack is empty
+	}
+	index := len(s.elements) - 1
+	popped := s.elements[index]
+	s.elements = s.elements[:index]
+	return popped
 }

structure/stack/stacklinkedlist.go

@@ -22,7 +22,7 @@ type Stack struct {
 }
 
 // push add value to last index
-func (ll *Stack) push(n any) {
+func (ll *Stack) Push(n any) {
 	newStack := &Node{} // new node
 
 	newStack.Val = n
@@ -33,7 +33,7 @@ func (ll *Stack) push(n any) {
 }
 
 // pop remove last item as first output
-func (ll *Stack) pop() any {
+func (ll *Stack) Pop() any {
 	result := ll.top.Val
 	if ll.top.Next == nil {
 		ll.top = nil
@@ -46,22 +46,22 @@ func (ll *Stack) pop() any {
 }
 
 // isEmpty to check our array is empty or not
-func (ll *Stack) isEmpty() bool {
+func (ll *Stack) IsEmpty() bool {
 	return ll.length == 0
 }
 
 // len use to return length of our stack
-func (ll *Stack) len() int {
+func (ll *Stack) Length() int {
 	return ll.length
 }
 
 // peak return last input value
-func (ll *Stack) peak() any {
+func (ll *Stack) Peek() any {
 	return ll.top.Val
 }
 
 // show all value as an interface array
-func (ll *Stack) show() (in []any) {
+func (ll *Stack) Show() (in []any) {
 	current := ll.top
 
 	for current != nil {

structure/stack/stacklinkedlistwithlist.go

@@ -16,18 +16,18 @@ import (
 
 // SList is our struct that point to stack with container/list.List library
 type SList struct {
-	stack *list.List
+	Stack *list.List
 }
 
 // Push add a value into our stack
 func (sl *SList) Push(val any) {
-	sl.stack.PushFront(val)
+	sl.Stack.PushFront(val)
 }
 
 // Peak is return last value that insert into our stack
-func (sl *SList) Peak() (any, error) {
-	if !sl.Empty() {
-		element := sl.stack.Front()
+func (sl *SList) Peek() (any, error) {
+	if !sl.IsEmpty() {
+		element := sl.Stack.Front()
 		return element.Value, nil
 	}
 	return "", fmt.Errorf("stack list is empty")
@@ -36,11 +36,11 @@ func (sl *SList) Peak() (any, error) {
 // Pop is return last value that insert into our stack
 // also it will remove it in our stack
 func (sl *SList) Pop() (any, error) {
-	if !sl.Empty() {
+	if !sl.IsEmpty() {
 		// get last element that insert into stack
-		element := sl.stack.Front()
+		element := sl.Stack.Front()
 		// remove element in stack
-		sl.stack.Remove(element)
+		sl.Stack.Remove(element)
 		// return element value
 		return element.Value, nil
 	}
@@ -49,12 +49,12 @@ func (sl *SList) Pop() (any, error) {
 
 // Length return length of our stack
 func (sl *SList) Length() int {
-	return sl.stack.Len()
+	return sl.Stack.Len()
 }
 
 // Empty check our stack has value or not
-func (sl *SList) Empty() bool {
+func (sl *SList) IsEmpty() bool {
 	// check our stack is empty or not
 	// if is 0 it means our stack is empty otherwise is not empty
-	return sl.stack.Len() == 0
+	return sl.Stack.Len() == 0
 }