scratch @ efe3f18

M algos/queue_test.go

···
                31
                31
                 	is(t, ok, true)

              
                32
                32
                 	is(t, v, 11)

              
                33
                33
                 

              
                
                34
                +	_, ok = q.Pop()

              
                
                35
                +	is(t, ok, false)

              
                
                36
                +

              
                34
                37
                 	// everything works after removing all elements

              
                35
                38
                 	q.Push(69420)

              
                36
                39
                 	is(t, q.Peek(), 69420)

              

A algos/stack.go

···
                
                1
                +package algos

              
                
                2
                +

              
                
                3
                +type SNode[T any] struct {

              
                
                4
                +	v    T

              
                
                5
                +	prev *SNode[T]

              
                
                6
                +}

              
                
                7
                +

              
                
                8
                +type Stack[T any] struct {

              
                
                9
                +	Len  int

              
                
                10
                +	head *SNode[T]

              
                
                11
                +}

              
                
                12
                +

              
                
                13
                +func (s *Stack[T]) Push(item T) {

              
                
                14
                +	node := &SNode[T]{v: item, prev: s.head}

              
                
                15
                +	s.head = node

              
                
                16
                +	s.Len++

              
                
                17
                +}

              
                
                18
                +

              
                
                19
                +func (s *Stack[T]) Peek() T {

              
                
                20
                +	return s.head.v

              
                
                21
                +}

              
                
                22
                +

              
                
                23
                +func (s *Stack[T]) Pop() (val T, ok bool) {

              
                
                24
                +	if s.Len == 0 {

              
                
                25
                +		var t T

              
                
                26
                +		return t, false

              
                
                27
                +	}

              
                
                28
                +	res := s.head.v

              
                
                29
                +	s.head = s.head.prev

              
                
                30
                +	s.Len--

              
                
                31
                +	return res, true

              
                
                32
                +}

              

A algos/stack_test.go

···
                
                1
                +package algos

              
                
                2
                +

              
                
                3
                +import "testing"

              
                
                4
                +

              
                
                5
                +func TestStack(t *testing.T) {

              
                
                6
                +	s := Stack[int]{}

              
                
                7
                +

              
                
                8
                +	s.Push(5)

              
                
                9
                +	s.Push(7)

              
                
                10
                +	s.Push(9)

              
                
                11
                +

              
                
                12
                +	v, ok := s.Pop()

              
                
                13
                +	is(t, ok, true)

              
                
                14
                +	is(t, v, 9)

              
                
                15
                +

              
                
                16
                +	is(t, s.Len, 2)

              
                
                17
                +

              
                
                18
                +	s.Push(11)

              
                
                19
                +

              
                
                20
                +	v, ok = s.Pop()

              
                
                21
                +	is(t, ok, true)

              
                
                22
                +	is(t, v, 11)

              
                
                23
                +

              
                
                24
                +	v, ok = s.Pop()

              
                
                25
                +	is(t, ok, true)

              
                
                26
                +	is(t, v, 7)

              
                
                27
                +

              
                
                28
                +	is(t, s.Peek(), 5)

              
                
                29
                +

              
                
                30
                +	v, ok = s.Pop()

              
                
                31
                +	is(t, ok, true)

              
                
                32
                +	is(t, v, 5)

              
                
                33
                +

              
                
                34
                +	_, ok = s.Pop()

              
                
                35
                +	is(t, ok, false)

              
                
                36
                +

              
                
                37
                +	s.Push(69420)

              
                
                38
                +	is(t, s.Peek(), 69420)

              
                
                39
                +

              
                
                40
                +	v, ok = s.Pop()

              
                
                41
                +	is(t, ok, true)

              
                
                42
                +	is(t, v, 69420)

              
                
                43
                +}