def7a0b472ae26985d59a098983c7b55.png

更多Python学习内容：ipengtao.com

在计算机科学中，栈（Stack）和队列（Queue）是两种常见的数据结构。它们在算法和数据处理方面有着广泛的应用。本文将详细介绍如何在Python中实现自定义的栈与队列，并包含详细的示例代码，帮助深入理解这两种数据结构的工作原理和使用方法。

栈（Stack）

什么是栈

栈是一种遵循后进先出（LIFO, Last In First Out）原则的线性数据结构。栈的基本操作包括压栈（push）、弹栈（pop）和查看栈顶元素（peek）。

栈的基本操作

  1. 压栈（push）：将元素添加到栈顶。

  2. 弹栈（pop）：从栈顶移除元素。

  3. 查看栈顶元素（peek）：获取栈顶元素但不移除它。

  4. 检查栈是否为空（is_empty）：检查栈是否为空。

  5. 获取栈的大小（size）：获取栈中元素的数量。

实现自定义栈

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

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

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

    def pop(self):
        if self.is_empty():
            raise IndexError("pop from empty stack")
        return self.items.pop()

    def peek(self):
        if self.is_empty():
            raise IndexError("peek from empty stack")
        return self.items[-1]

    def size(self):
        return len(self.items)

    def __str__(self):
        return "Stack: " + str(self.items)

# 示例
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack)  # 输出: Stack: [1, 2, 3]
print("栈顶元素:", stack.peek())  # 输出: 栈顶元素: 3
print("弹栈元素:", stack.pop())  # 输出: 弹栈元素: 3
print(stack)  # 输出: Stack: [1, 2]

队列（Queue）

什么是队列

队列是一种遵循先进先出（FIFO, First In First Out）原则的线性数据结构。队列的基本操作包括入队（enqueue）、出队（dequeue）和查看队头元素（front）。

队列的基本操作

  1. 入队（enqueue）：将元素添加到队尾。

  2. 出队（dequeue）：从队头移除元素。

  3. 查看队头元素（front）：获取队头元素但不移除它。

  4. 检查队列是否为空（is_empty）：检查队列是否为空。

  5. 获取队列的大小（size）：获取队列中元素的数量。

实现自定义队列

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

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

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

    def dequeue(self):
        if self.is_empty():
            raise IndexError("dequeue from empty queue")
        return self.items.pop(0)

    def front(self):
        if self.is_empty():
            raise IndexError("front from empty queue")
        return self.items[0]

    def size(self):
        return len(self.items)

    def __str__(self):
        return "Queue: " + str(self.items)

# 示例
queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print(queue)  # 输出: Queue: [1, 2, 3]
print("队头元素:", queue.front())  # 输出: 队头元素: 1
print("出队元素:", queue.dequeue())  # 输出: 出队元素: 1
print(queue)  # 输出: Queue: [2, 3]

栈与队列的应用

栈的应用：括号匹配

栈常用于检查表达式中的括号是否匹配。

def is_balanced(expression):
    stack = Stack()
    matching_brackets = {')': '(', ']': '[', '}': '{'}
    for char in expression:
        if char in matching_brackets.values():
            stack.push(char)
        elif char in matching_brackets.keys():
            if stack.is_empty() or stack.pop() != matching_brackets[char]:
                return False
    return stack.is_empty()

# 示例
expression = "{[()]}"
print(f"表达式 {expression} 是否平衡: {is_balanced(expression)}")  # 输出: 表达式 {[()]} 是否平衡: True

队列的应用：任务调度

队列常用于任务调度，按顺序处理任务。

def task_scheduler(tasks):
    queue = Queue()
    for task in tasks:
        queue.enqueue(task)
    while not queue.is_empty():
        current_task = queue.dequeue()
        print(f"处理任务: {current_task}")

# 示例
tasks = ["任务1", "任务2", "任务3"]
task_scheduler(tasks)
# 输出:
# 处理任务: 任务1
# 处理任务: 任务2
# 处理任务: 任务3

栈与队列的高级实现

使用链表实现栈

链表是一种动态数据结构，可以用于实现灵活的栈。

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

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

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

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

    def pop(self):
        if self.is_empty():
            raise IndexError("pop from empty stack")
        data = self.top.data
        self.top = self.top.next
        return data

    def peek(self):
        if self.is_empty():
            raise IndexError("peek from empty stack")
        return self.top.data

    def size(self):
        count = 0
        current = self.top
        while current:
            count += 1
            current = current.next
        return count

    def __str__(self):
        result = []
        current = self.top
        while current:
            result.append(current.data)
            current = current.next
        return "LinkedListStack: " + str(result)

# 示例
stack = LinkedListStack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack)  # 输出: LinkedListStack: [3, 2, 1]
print("栈顶元素:", stack.peek())  # 输出: 栈顶元素: 3
print("弹栈元素:", stack.pop())  # 输出: 弹栈元素: 3
print(stack)  # 输出: LinkedListStack: [2, 1]

使用链表实现队列

同样地，链表也可以用于实现灵活的队列。

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

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

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

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

    def dequeue(self):
        if self.is_empty():
            raise IndexError("dequeue from empty queue")
        data = self.front.data
        self.front = self.front.next
        if self.front is None:
            self.rear = None
        return data

    def front(self):
        if self.is_empty():
            raise IndexError("front from empty queue")
        return self.front.data

    def size(self):
        count = 0
        current = self.front
        while current:
            count += 1
            current = current.next
        return count

    def __str__(self):
        result = []
        current = self.front
        while current:
            result.append(current.data)
            current = current.next
        return "LinkedListQueue: " + str(result)

# 示例
queue = LinkedListQueue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print(queue)  # 输出: LinkedListQueue: [1, 2, 3]
print("队头元素:", queue.front())  # 输出: 队头元素: 1
print("出队元素:", queue.dequeue())  # 输出: 出队元素: 1
print(queue)  # 输出: LinkedListQueue: [2, 3]

总结

本文详细介绍了如何在Python中实现自定义的栈与队列，包括基本操作、链表实现以及常见应用场景。栈和队列是基础的数据结构，在算法设计和数据处理方面有着广泛的应用。通过掌握这些数据结构的实现和使用方法，可以帮助大家在编程中更好地组织和管理数据，提高程序的效率和可读性。

如果你觉得文章还不错，请大家 点赞、分享、留言 下，因为这将是我持续输出更多优质文章的最强动力！

如果想要系统学习Python、Python问题咨询，或者考虑做一些工作以外的副业，都可以扫描二维码添加微信，围观朋友圈一起交流学习。

8ebcf4e75296281bd0e0ca4251873c30.gif

我们还为大家准备了Python资料和副业项目合集，感兴趣的小伙伴快来找我领取一起交流学习哦！

3978414346cde26a0f79a5824e0246c5.jpeg

往期推荐

历时一个月整理的 Python 爬虫学习手册全集PDF（免费开放下载）

Python基础学习常见的100个问题.pdf（附答案）

学习 数据结构与算法，这是我见过最友好的教程！(PDF免费下载)

Python办公自动化完全指南(免费PDF)

Python Web 开发常见的100个问题.PDF

肝了一周，整理了Python 从0到1学习路线（附思维导图和PDF下载）

# python # 数据结构 # 开发语言
Logo
魔乐社区

魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。

更多推荐

cover

大数据毕业设计选题推荐-基于大数据的农作物产量数据分析与可视化系统-Hadoop-Spark-数据可视化-BigData

avatar 魔乐社区
cover

大模型推理适配实战：手把手带你完成vLLM Ascend迁移实操

avatar 魔乐社区
cover

基于python大数据的汽车数据分析系统设计与实现

avatar 魔乐社区