Python数据结构：实现自定义栈与队列

大家好，我是涛哥，本文内容来自 涛哥聊Python ，转载请标原创。

更多Python学习内容：http://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中实现自定义的栈与队列，包括基本操作、链表实现以及常见应用场景。栈和队列是基础的数据结构，在算法设计和数据处理方面有着广泛的应用。通过掌握这些数据结构的实现和使用方法，可以帮助大家在编程中更好地组织和管理数据，提高程序的效率和可读性。