熟练掌控栈与队列，数据结构将不再是噩梦！

后端

2023-12-10 10:27:39

栈：有序的后进先出

栈是一种遵循“后进先出”（Last-In-First-Out，LIFO）原则的数据结构，就好比一摞盘子，最先放进去的盘子最后取出来。栈具有如下特征：

先进后出（LIFO）： 后放入栈中的元素，首先被移出。
只允许在栈顶进行插入和删除操作： 只能从栈顶添加或移除元素。
元素次序遵循后进先出原则： 栈顶元素始终是最近添加的元素。

栈在计算机科学中有广泛的应用，比如：

函数调用： 函数调用时，局部变量和函数参数会被压入栈中，函数返回时，这些变量被弹出。
表达式求值： 运算符和操作数会被压入栈中，按照运算符的优先级进行计算，计算结果从栈中弹出。
递归： 递归函数在调用自身时，当前函数的状态会被压入栈中，递归返回时，当前函数的状态从栈中弹出。

队列：有序的先进先出

队列是一种遵循“先进先出”（First-In-First-Out，FIFO）原则的数据结构，就好比一条长龙，先排队的人先被服务。队列具有如下特征：

先进先出（FIFO）： 先放入队列中的元素，首先被移除。
只允许在队尾进行插入操作，只允许在队首进行删除操作： 元素只能从队尾加入，只能从队首移出。
元素次序遵循先进先出原则： 队首元素始终是最早添加的元素。

队列在计算机科学中有广泛的应用，比如：

进程调度： 操作系统使用队列来管理进程，先提交的进程首先被执行。
消息传递： 消息队列用于在进程之间传递消息，先发送的消息首先被处理。
缓冲： 队列可用于缓冲数据，比如网络数据传输时，数据会被先存入队列中，然后再发送出去。

栈与队列的应用

栈和队列在计算机科学中有着广泛的应用。以下是一些常见的应用场景：

栈：
- 函数调用： 当函数被调用时，其参数和局部变量会被压入栈中。当函数返回时，这些变量会被弹出。
- 表达式求值： 当表达式被求值时，操作数和运算符会被压入栈中。按照运算符的优先级，从栈中弹出操作数和运算符进行计算。计算结果会被压入栈中。
- 递归： 当一个函数调用自身时，当前函数的状态会被压入栈中。当递归函数返回时，当前函数的状态会被弹出。
队列：
- 进程调度： 操作系统使用队列来管理进程。当进程需要被执行时，会被放入队列中。队列中的进程按照先进先出的原则被执行。
- 消息传递： 消息队列用于在进程之间传递消息。当进程需要发送消息时，会将消息放入队列中。当进程需要接收消息时，会从队列中取出消息。
- 缓冲： 队列可用于缓冲数据。例如，当数据从网络中接收时，会被先存入队列中。当需要处理数据时，数据会被从队列中取出。

栈与队列的比较

栈和队列都是非常重要的数据结构，它们在计算机科学中有着广泛的应用。栈遵循“后进先出”的原则，队列遵循“先进先出”的原则。栈只允许在栈顶进行插入和删除操作，队列只允许在队尾进行插入操作和在队首进行删除操作。栈和队列都有着广泛的应用，在不同的场景中发挥着各自的作用。

栈与队列的实现

栈和队列都可以使用数组或链表来实现。数组实现简单，但是插入和删除元素需要移动元素，效率较低。链表实现复杂一些，但是插入和删除元素只需要改变指针，效率较高。

数组实现

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def peek(self):
        return self.items[-1]

    def is_empty(self):
        return len(self.items) == 0

class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        return self.items.pop(0)

    def peek(self):
        return self.items[0]

    def is_empty(self):
        return len(self.items) == 0

链表实现

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Stack:
    def __init__(self):
        self.top = None

    def push(self, item):
        new_node = Node(item)
        new_node.next = self.top
        self.top = new_node

    def pop(self):
        if self.top is None:
            return None
        item = self.top.data
        self.top = self.top.next
        return item

    def peek(self):
        if self.top is None:
            return None
        return self.top.data

    def is_empty(self):
        return self.top is None

class Queue:
    def __init__(self):
        self.front = None
        self.rear = None

    def enqueue(self, item):
        new_node = Node(item)
        if self.rear is None:
            self.front = new_node
            self.rear = new_node
        else:
            self.rear.next = new_node
            self.rear = new_node

    def dequeue(self):
        if self.front is None:
            return None
        item = self.front.data
        self.front = self.front.next
        if self.front is None:
            self.rear = None
        return item

    def peek(self):
        if self.front is None:
            return None
        return self.front.data

    def is_empty(self):
        return self.front is None