栈

栈

栈是一种遵循先入后出逻辑的线性数据结构。

我们把堆叠元素的顶部称为“栈顶”，底部称为“栈底”。

将把元素添加到栈顶的操作叫作“入栈”，删除栈顶元素的操作叫作“出栈”。

栈的常用操作

方法	描述	时间复杂度
push()	元素入栈（添加至栈顶）	O(1)
pop()	栈顶元素出栈	O(1)
peek()	访问栈顶元素	O(1)

在 Go 中，推荐将 Slice 当作栈来使用

/* 初始化栈 */
// 在 Go 中，推荐将 Slice 当作栈来使用
var stack []int
​
/* 元素入栈 */
stack = append(stack, 1)
stack = append(stack, 3)
stack = append(stack, 2)
stack = append(stack, 5)
stack = append(stack, 4)
​
/* 访问栈顶元素 */
peek := stack[len(stack)-1]
​
/* 元素出栈 */
pop := stack[len(stack)-1]
stack = stack[:len(stack)-1]
​
/* 获取栈的长度 */
size := len(stack)
​
/* 判断是否为空 */
isEmpty := len(stack) == 0

栈的实现

栈遵循先入后出的原则，我们只能在栈顶添加或删除元素。然而，数组和链表都可以在任意位置添加和删除元素，因此栈可以视为一种受限制的数组或链表。要实现栈，需要“屏蔽”数组或链表的部分无关操作，使其对外表现的逻辑符合栈的特性。

基于链表的实现

使用链表实现栈时，我们可以将链表的头节点视为栈顶，尾节点视为栈底。

入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。

出栈操作，只需将头节点从链表中删除即可。

/* 基于链表实现的栈 */
type linkedListStack struct {
    // 使用内置包 list 来实现栈
    data *list.List
}
​
/* 初始化栈 */
func newLinkedListStack() *linkedListStack {
    return &linkedListStack{
        data: list.New(),
    }
}
​
/* 入栈 */
func (s *linkedListStack) push(value int) {
    s.data.PushBack(value)
}
​
/* 出栈 */
func (s *linkedListStack) pop() any {
    if s.isEmpty() {
        return nil
    }
    e := s.data.Back()
    s.data.Remove(e)
    return e.Value
}
​
/* 访问栈顶元素 */
func (s *linkedListStack) peek() any {
    if s.isEmpty() {
        return nil
    }
    e := s.data.Back()
    return e.Value
}
​
/* 获取栈的长度 */
func (s *linkedListStack) size() int {
    return s.data.Len()
}
​
/* 判断栈是否为空 */
func (s *linkedListStack) isEmpty() bool {
    return s.data.Len() == 0
}
​
/* 获取 List 用于打印 */
func (s *linkedListStack) toList() *list.List {
    return s.data
}

基于数组的实现

使用数组实现栈时，我们可以将数组的尾部作为栈顶。入栈与出栈操作分别对应在数组尾部添加元素与删除元素

/* 基于数组实现的栈 */
type arrayStack struct {
    data []int // 数据
}
​
/* 初始化栈 */
func newArrayStack() *arrayStack {
    return &arrayStack{
        // 设置栈的长度为 0，容量为 16
        data: make([]int, 0, 16),
    }
}
​
/* 栈的长度 */
func (s *arrayStack) size() int {
    return len(s.data)
}
​
/* 栈是否为空 */
func (s *arrayStack) isEmpty() bool {
    return s.size() == 0
}
​
/* 入栈 */
func (s *arrayStack) push(v int) {
    // 切片会自动扩容
    s.data = append(s.data, v)
}
​
/* 出栈 */
func (s *arrayStack) pop() any {
    val := s.peek()
    s.data = s.data[:len(s.data)-1]
    return val
}
​
/* 获取栈顶元素 */
func (s *arrayStack) peek() any {
    if s.isEmpty() {
        return nil
    }
    val := s.data[len(s.data)-1]
    return val
}
​
/* 获取 Slice 用于打印 */
func (s *arrayStack) toSlice() []int {
    return s.data
}