/
stack.go
108 lines (87 loc) · 1.68 KB
/
stack.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package stack
import (
"errors"
"sort"
"github.com/yms2772/stack/comparator"
"golang.org/x/exp/constraints"
)
// New stack
func New[T constraints.Ordered]() Stack[T] {
return &stack[T]{
data: []T{},
}
}
// Clean stack
func (s *stack[T]) Clean() {
s.data = s.data[:0]
}
// Data is print all data
func (s *stack[T]) Data() []T {
return s.data
}
// Empty stack
func (s *stack[T]) Empty() (empty bool) {
return len(s.data) == 0
}
// Index stack
func (s *stack[T]) Index(index int) (data T, err error) {
if index >= s.Size() {
return data, errors.New("overflow")
}
return s.data[index-1], nil
}
// Pop from stack
func (s *stack[T]) Pop() (data T) {
if !s.Empty() {
data = s.data[len(s.data)-1]
s.data = s.data[:len(s.data)-1]
return data
}
return data
}
// Peek from stack
func (s *stack[T]) Peek() (data T) {
if !s.Empty() {
return (s.data)[len(s.data)-1]
}
return data
}
// Push to stack
func (s *stack[T]) Push(data T) {
s.data = append(s.data, data)
}
// Remove element of stack
func (s *stack[T]) Remove(index int) {
s.data = append(s.data[:index], s.data[index+1:]...)
}
// Search stack
func (s *stack[T]) Search(data T) (index int) {
if s.Empty() {
return 0
}
for i, item := range s.data {
if item == data {
return i
}
}
return 0
}
// Size stack
func (s *stack[T]) Size() (length int) {
return len(s.data)
}
// Sort stack by string
// Default: Ascending
func (s *stack[T]) Sort(c ...comparator.Comparator) {
sort.Slice(s.data, func(i, j int) bool {
if len(c) != 0 {
switch c[0] {
case comparator.ASC:
return s.data[i] < s.data[j]
case comparator.DESC:
return s.data[i] > s.data[j]
}
}
return s.data[i] < s.data[j]
})
}