数据结构第一课-队列与栈

好的，下面我将通过 Go 语言来详细的讲解数据结构中的队列和栈。

队列

队列是一种线性数据结构，它是按照先进先出（FIFO）的原则进行操作的。队列可以用数组或链表来实现。在队列中，新元素插入到队尾，已有元素从队头被移除。

常见的队列操作包括：

• Enqueue：向队列尾部添加一个元素。
• Dequeue：从队列头部删除一个元素。
• Peek：查看队头元素，但不删除该元素。

以下是使用 Go 语言实现队列的示例代码：

package main

import "fmt"

type Queue struct {
    items []int
}

// 将元素添加到队列尾部
func (q *Queue) Enqueue(i int) {
    q.items = append(q.items, i)
}

// 从队列头部删除元素
func (q *Queue) Dequeue() int {
    toRemove := q.items[0]
    q.items = q.items[1:]
    return toRemove
}

// 查看队头元素，但不删除
func (q *Queue) Peek() int {
    return q.items[0]
}

// 判断队列是否为空
func (q *Queue) IsEmpty() bool {
    return len(q.items) == 0
}

func main() {
    q := Queue{}

    // 向队列添加元素
    q.Enqueue(1)
    q.Enqueue(2)
    q.Enqueue(3)

    // 查看队头元素
    fmt.Println(q.Peek()) // 输出 1

    // 从队列头部删除元素
    fmt.Println(q.Dequeue()) // 输出 1
    fmt.Println(q.Dequeue()) // 输出 2

    // 判断队列是否为空
    fmt.Println(q.IsEmpty()) // 输出 false
}

在上面的代码中，我们定义了一个 Queue 结构体，并实现了向队列尾部添加元素、从队列头部删除元素、查看队头元素以及判断队列是否为空等操作。

栈

栈是一种线性数据结构，它按照先进后出（LIFO）的原则进行操作。栈可以用数组或链表来实现。在栈中，新元素被添加到栈顶，已有元素从栈顶被移除。

常见的栈操作包括：

• Push：将元素添加到栈顶。
• Pop：从栈顶删除元素。
• Peek：查看栈顶元素，但不删除该元素。

以下是使用 Go 语言实现栈的示例代码：

package main

import "fmt"

type Stack struct {
    items []int
}

// 将元素添加到栈顶
func (s *Stack) Push(i int) {
    s.items = append(s.items, i)
}

// 从栈顶删除元素
func (s *Stack) Pop() int {
    toRemove := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return toRemove
}

// 查看栈顶元素，但不删除
func (s *Stack) Peek() int {
    return s.items[len(s.items)-1]
}

// 判断栈是否为空
func (s *Stack) IsEmpty() bool {
    return len(s.items) == 0
}

func main() {
    s := Stack{}

    // 将元素添加到栈顶
    s.Push(1)
    s.Push(2)
    s.Push(3)

    // 查看栈顶元素
    fmt.Println(s.Peek()) // 输出 3

    // 从栈顶删除元素
    fmt.Println(s.Pop()) // 输出 3
    fmt.Println(s.Pop()) // 输出 2

    // 判断栈是否为空
    fmt.Println(s.IsEmpty()) // 输出 false
}

在上面的代码中，我们定义了一个 Stack 结构体，并实现了将元素添加到栈顶、从栈顶删除元素