git/lancet
1
0
Fork 0
mirror of https://github.com/duke-git/lancet.git synced 2026-02-04 12:52:28 +08:00
Code Issues Projects Releases Wiki Activity

rename: rename StackArray -> ArrayStack, StackLink -> LinkedStack

Browse Source
This commit is contained in:
dudaodong
2022-02-10 11:49:46 +08:00
parent 5ae746a1f0
commit 20e1836eb7
5 changed files with 12 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
datastructure/node.go
View File

@@ -12,7 +12,7 @@ func NewLinkNode[T any](value T) *LinkNode[T] {
return &LinkNode[T]{value, nil, nil}
}
// StackNode is a node in stack, which have a Value and Pre points to previous node in the stack.
// StackNode is a node in stack, which have a Value and Next pointer points to next node in the stack.
type StackNode[T any] struct {
Value T
Next *StackNode[T]
@@ -22,3 +22,14 @@ type StackNode[T any] struct {
func NewStackNode[T any](value T) *StackNode[T] {
return &StackNode[T]{value, nil}
}
// QueueNode is a node in a queue, which have a Value and Next pointer points to next node in the queue.
type QueueNode[T any] struct {
Value T
Next *StackNode[T]
}
// NewQueueNode return a QueueNode pointer
func NewQueueNode[T any](value T) *QueueNode[T] {
return &QueueNode[T]{value, nil}
}

62
datastructure/stackarray.go
View File

@@ -1,62 +0,0 @@
package datastructure
import "errors"
// StackArray implements stack with slice
type StackArray[T any] struct {
data []T
length int
}
// NewStackArray return a empty StackArray pointer
func NewStackArray[T any]() *StackArray[T] {
return &StackArray[T]{data: []T{}, length: 0}
}
// Data return stack data
func (s *StackArray[T]) Data() []T {
return s.data
}
// Length return length of stack data
func (s *StackArray[T]) Length() int {
return s.length
}
// IsEmpty checks if stack is empty or not
func (s *StackArray[T]) IsEmpty() bool {
return s.length == 0
}
// Push element into stack
func (s *StackArray[T]) Push(value T) {
s.data = append([]T{value}, s.data...)
s.length++
}
// Pop delete the top element of stack then return it, if stack is empty, return nil and error
func (s *StackArray[T]) Pop() (*T, error) {
if s.IsEmpty() {
return nil, errors.New("stack is empty")
}
topItem := s.data[0]
s.data = s.data[1:]
s.length--
return &topItem, nil
}
// Peak return the top element of stack then return it
func (s *StackArray[T]) Peak() (*T, error) {
if s.IsEmpty() {
return nil, errors.New("stack is empty")
}
return &s.data[0], nil
}
// EmptyStack clear the stack data
func (s *StackArray[T]) EmptyStack() {
s.data = []T{}
s.length = 0
}

77
datastructure/stackarray_test.go
View File

@@ -1,77 +0,0 @@
package datastructure
import (
"testing"
"github.com/duke-git/lancet/internal"
)
func TestStackArray_Push(t *testing.T) {
assert := internal.NewAssert(t, "TestStackArray_Push")
stack := NewStackArray[int]()
stack.Push(1)
stack.Push(2)
stack.Push(3)
expected := []int{3, 2, 1}
values := stack.Data()
length := stack.Length()
assert.Equal(expected, values)
assert.Equal(3, length)
}
func TestStackArray_Pop(t *testing.T) {
assert := internal.NewAssert(t, "TestStackArray_Pop")
stack := NewStackArray[int]()
topItem, err := stack.Pop()
assert.IsNotNil(err)
stack.Push(1)
stack.Push(2)
stack.Push(3)
topItem, err = stack.Pop()
assert.IsNil(err)
assert.Equal(3, *topItem)
expected := []int{2, 1}
assert.Equal(expected, stack.Data())
}
func TestStackArray_Peak(t *testing.T) {
assert := internal.NewAssert(t, "TestStackArray_Peak")
stack := NewStackArray[int]()
topItem, err := stack.Peak()
assert.IsNotNil(err)
stack.Push(1)
stack.Push(2)
stack.Push(3)
topItem, err = stack.Peak()
assert.IsNil(err)
assert.Equal(3, *topItem)
expected := []int{3, 2, 1}
assert.Equal(expected, stack.Data())
}
func TestStackArray_Empty(t *testing.T) {
assert := internal.NewAssert(t, "TestStackArray_Empty")
stack := NewStackArray[int]()
assert.Equal(true, stack.IsEmpty())
assert.Equal(0, stack.Length())
stack.Push(1)
assert.Equal(false, stack.IsEmpty())
assert.Equal(1, stack.Length())
stack.EmptyStack()
assert.Equal(true, stack.IsEmpty())
assert.Equal(0, stack.Length())
}

92
datastructure/stacklink.go
View File

@@ -1,92 +0,0 @@
package datastructure
import (
"errors"
"fmt"
)
// StackArray implements stack with link list
type StackLink[T any] struct {
top *StackNode[T]
length int
}
// NewStackLink return a empty StackLink pointer
func NewStackLink[T any]() *StackLink[T] {
return &StackLink[T]{top: nil, length: 0}
}
// Data return stack data
func (s *StackLink[T]) Data() []T {
res := []T{}
current := s.top
for current != nil {
res = append(res, current.Value)
current = current.Next
}
return res
}
// Length return length of stack data
func (s *StackLink[T]) Length() int {
return s.length
}
// IsEmpty checks if stack is empty or not
func (s *StackLink[T]) IsEmpty() bool {
return s.length == 0
}
// Push element into stack
func (s *StackLink[T]) Push(value T) {
newNode := NewStackNode(value)
top := s.top
if top == nil {
s.top = newNode
} else {
newNode.Next = top
s.top = newNode
}
s.length++
}
// Pop delete the top element of stack then return it, if stack is empty, return nil and error
func (s *StackLink[T]) Pop() (*T, error) {
if s.IsEmpty() {
return nil, errors.New("stack is empty")
}
top := s.top
s.top = s.top.Next
s.length--
return &top.Value, nil
}
// Peak return the top element of stack then return it
func (s *StackLink[T]) Peak() (*T, error) {
if s.IsEmpty() {
return nil, errors.New("stack is empty")
}
return &s.top.Value, nil
}
// EmptyStack clear the stack data
func (s *StackLink[T]) EmptyStack() {
s.top = nil
s.length = 0
}
// Print all nodes info of stack link
func (s *StackLink[T]) Print() {
current := s.top
info := "[ "
for current != nil {
info += fmt.Sprintf("%+v, ", current)
current = current.Next
}
info += " ]"
fmt.Println(info)
}

80
datastructure/stacklink_test.go
View File

@@ -1,80 +0,0 @@
package datastructure
import (
"testing"
"github.com/duke-git/lancet/internal"
)
func TestStackLink_Push(t *testing.T) {
assert := internal.NewAssert(t, "TestStackLink_Push")
stack := NewStackLink[int]()
stack.Push(1)
stack.Push(2)
stack.Push(3)
stack.Print()
expected := []int{3, 2, 1}
values := stack.Data()
length := stack.Length()
assert.Equal(expected, values)
assert.Equal(3, length)
}
func TestStackLink_Pop(t *testing.T) {
assert := internal.NewAssert(t, "TestStackLink_Pop")
stack := NewStackLink[int]()
topItem, err := stack.Pop()
assert.IsNotNil(err)
stack.Push(1)
stack.Push(2)
stack.Push(3)
topItem, err = stack.Pop()
assert.IsNil(err)
assert.Equal(3, *topItem)
expected := []int{2, 1}
stack.Print()
assert.Equal(expected, stack.Data())
}
func TestStackLink_Peak(t *testing.T) {
assert := internal.NewAssert(t, "TestStackLink_Peak")
stack := NewStackLink[int]()
topItem, err := stack.Peak()
assert.IsNotNil(err)
stack.Push(1)
stack.Push(2)
stack.Push(3)
topItem, err = stack.Peak()
assert.IsNil(err)
assert.Equal(3, *topItem)
expected := []int{3, 2, 1}
assert.Equal(expected, stack.Data())
}
func TestStackLink_Empty(t *testing.T) {
assert := internal.NewAssert(t, "TestStackLink_Empty")
stack := NewStackLink[int]()
assert.Equal(true, stack.IsEmpty())
assert.Equal(0, stack.Length())
stack.Push(1)
assert.Equal(false, stack.IsEmpty())
assert.Equal(1, stack.Length())
stack.EmptyStack()
assert.Equal(true, stack.IsEmpty())
assert.Equal(0, stack.Length())
}