队列和栈

队列

// Queue 表示一个整型队列。
// 同样使用 []int 实现，但出队发生在切片头部。
type Queue struct {
    data []int
}

func NewQueue() *Queue {
    return &Queue{
        data: make([]int, 0),
    }
}

// Enqueue 入队：把新元素追加到切片末尾。
func (q *Queue) Enqueue(value int) {
    q.data = append(q.data, value)
}

// Dequeue 出队：取出切片第一个元素。
// 队列为空时，同样返回错误。
func (q *Queue) Dequeue() (int, error) {
    if q.IsEmpty() {
        return 0, fmt.Errorf("队列为空，不能出队")
    }

    value := q.data[0]

    // 把第一个元素移除，剩余部分形成新的切片。
    // 这正好体现了队列“先进先出”的特性。
    q.data = q.data[1:]

    return value, nil
}

func (q *Queue) Len() int {
    return len(q.data)
}

func (q *Queue) IsEmpty() bool {
    return len(q.data) == 0
}

栈

// Stack 表示一个整型栈。
// 这里先用 []int 实现，比较适合学习 Go 中切片的用法。
type Stack struct {
    data []int
}

func NewStack() *Stack {
    return &Stack{
        data: make([]int, 0),
    }
}

// Push 入栈：把元素放到切片末尾。
// 因为栈顶放在切片尾部，所以追加元素就是入栈。
func (s *Stack) Push(value int) {
    s.data = append(s.data, value)
}

// Pop 出栈：取出切片最后一个元素。
// 如果栈为空，返回错误，避免直接访问越界。
func (s *Stack) Pop() (int, error) {
    if s.IsEmpty() {
        return 0, fmt.Errorf("栈为空，不能出栈")
    }

    lastIndex := len(s.data) - 1
    value := s.data[lastIndex]

    // 通过重新切片删除最后一个元素。
    s.data = s.data[:lastIndex]

    return value, nil
}

func (s *Stack) Len() int {
    return len(s.data)
}

func (s *Stack) IsEmpty() bool {
    return len(s.data) == 0
}