LinkedList学习示例模拟堆栈与队列数据结构

下面是一个使用Python编写的简单`LinkedList`类，以及如何使用这个类来模拟堆栈（Stack）和队列（Queue）数据结构的基本操作。

首先，定义`LinkedList`类，它包含基本的插入和删除操作：

class ListNode:
    def __init__(self, value=0, next=None):
        self.value = value
        self.next = next

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, value):
        """在链表末尾添加一个新节点"""
        if not self.head:
            self.head = ListNode(value)
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = ListNode(value)

    def delete_head(self):
        """删除并返回链表的头节点"""
        if self.head:
            temp = self.head
            self.head = self.head.next
            temp.next = None
            return temp.value
        return None

    def peek(self):
        """返回链表的头节点值，但不删除它"""
        if self.head:
            return self.head.value
        return None

    def is_empty(self):
        """检查链表是否为空"""
        return self.head is None

# 使用LinkedList模拟堆栈（Stack）
class Stack:
    def __init__(self):
        self.ll = LinkedList()

    def push(self, value):
        """向堆栈中添加一个元素"""
        self.ll.append(value)

    def pop(self):
        """从堆栈中移除并返回顶部元素"""
        return self.ll.delete_head()

    def peek(self):
        """返回堆栈的顶部元素，但不移除它"""
        return self.ll.peek()

    def is_empty(self):
        """检查堆栈是否为空"""
        return self.ll.is_empty()

# 使用LinkedList模拟队列（Queue）
class Queue:
    def __init__(self):
        self.ll = LinkedList()

    def enqueue(self, value):
        """向队列中添加一个元素"""
        self.ll.append(value)

    def dequeue(self):
        """从队列中移除并返回前端元素"""
        return self.ll.delete_head()

    def front(self):
        """返回队列的前端元素，但不移除它"""
        return self.ll.peek()

    def is_empty(self):
        """检查队列是否为空"""
        return self.ll.is_empty()

# 示例使用
stack = Stack()
stack.push(1)
stack.push(2)
print(stack.pop())  # 输出: 2
print(stack.peek()) # 输出: 1

queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
print(queue.dequeue())  # 输出: 1
print(queue.front())    # 输出: 2

这个示例展示了如何使用`LinkedList`类来模拟堆栈和队列的基本操作。堆栈遵循后进先出（LIFO）的原则，而队列遵循先进先出（FIFO）的原则。