栈与队列

栈(先进后出)

基于链表实现栈

class ListNode:
    """链表节点类"""
    def __init__(self, val: int):
        self.val: int = val               # 节点值
        self.next: ListNode | None = None # 指向下一节点的引用

class LinkedListStack:
    """基于链表实现的栈"""

    def __init__(self):
        """构造方法"""
        self._peek: ListNode | None = None
        self._size: int = 0

    def size(self) -> int:
        """获取栈的长度"""
        return self._size

    def is_empty(self) -> bool:
        """判断栈是否为空"""
        return self._size == 0

    def push(self, val: int):
        """入栈"""
        node = ListNode(val)
        node.next = self._peek
        self._peek = node
        self._size += 1

    def pop(self) -> int:
        """出栈"""
        num = self.peek()
        self._peek = self._peek.next
        self._size -= 1
        return num

    def peek(self) -> int:
        """访问栈顶元素"""
        if self.is_empty():
            raise IndexError("栈为空")
        return self._peek.val

    def to_list(self) -> list[int]:
        """转化为列表用于打印"""
        arr = []
        node = self._peek
        while node:
            arr.append(node.val)
            node = node.next
        arr.reverse()
        return arr

if __name__ == '__main__':
    stack= LinkedListStack()
    stack.push(1)
    print(stack.to_list())
    stack.push(2)
    print(stack.to_list())
    stack.push(3)
    print(stack.to_list())
    stack.pop()
    stack.pop()
    print(stack.to_list())

## 执行结果：
# [1]
# [1, 2]
# [1, 2, 3]
# [1]

基于数组实现栈

class ArrayStack:
    """基于数组实现的栈"""

    def __init__(self):
        """构造方法"""
        self._stack: list[int] = []

    def size(self) -> int:
        """获取栈的长度"""
        return len(self._stack)

    def is_empty(self) -> bool:
        """判断栈是否为空"""
        return self.size() == 0

    def push(self, item: int):
        """入栈"""
        self._stack.append(item)

    def pop(self) -> int:
        """出栈"""
        if self.is_empty():
            raise IndexError("栈为空")
        return self._stack.pop()

    def peek(self) -> int:
        """访问栈顶元素"""
        if self.is_empty():
            raise IndexError("栈为空")
        return self._stack[-1]

    def to_list(self) -> list[int]:
        """返回列表用于打印"""
        return self._stack

if __name__ == '__main__':
    stack = ArrayStack()
    stack.push(1)
    print(stack.to_list())
    stack.push(2)
    print(stack.to_list())
    stack.push(3)
    print(stack.to_list())
    stack.pop()
    stack.pop()
    print(stack.to_list())

## 执行结果：
# [1]
# [1, 2]
# [1, 2, 3]
# [1]

队列(先进先出)

基于链表实现普通队列

# ListNode 另外实现
class ListNode:
    """链表节点类"""
    def __init__(self, val: int):
        self.val: int = val               # 节点值
        self.next: ListNode | None = None # 指向下一节点的引用

class LinkedListQueue:
    """基于链表实现的队列"""

    def __init__(self):
        """构造方法"""
        self._front: ListNode | None = None  # 头节点 front
        self._rear: ListNode | None = None  # 尾节点 rear
        self._size: int = 0

    def size(self) -> int:
        """获取队列的长度"""
        return self._size

    def is_empty(self) -> bool:
        """判断队列是否为空"""
        return self._size == 0

    def push(self, num: int):
        """入队"""
        # 在尾节点后添加 num
        node = ListNode(num)
        # 如果队列为空，则令头、尾节点都指向该节点
        if self._front is None:
            self._front = node
            self._rear = node
        # 如果队列不为空，则将该节点添加到尾节点后
        else:
            self._rear.next = node
            self._rear = node
        self._size += 1

    def pop(self) -> int:
        """出队"""
        num = self.peek()
        # 删除头节点
        self._front = self._front.next
        self._size -= 1
        return num

    def peek(self) -> int:
        """访问队首元素"""
        if self.is_empty():
            raise IndexError("队列为空")
        return self._front.val

    def to_list(self) -> list[int]:
        """转化为列表用于打印"""
        queue = []
        temp = self._front
        while temp:
            queue.append(temp.val)
            temp = temp.next
        return queue

if __name__ == '__main__':
    que = LinkedListQueue()
    que.push(1)
    print(que.to_list())
    que.push(2)
    print(que.to_list())
    que.push(3)
    print(que.to_list())
    que.pop()
    que.pop()
    print(que.to_list())

## 执行结果：
# [1]
# [1, 2]
# [1, 2, 3]
# [3]

基于数组实现环形队列

class RingQueue:
    """基于数组实现的环形队列"""

    def __init__(self, size: int):
        """构造方法"""
        self._nums: list[int] = [0] * size # 用于存储队列元素的数组
        self._front: int = 0 # 队首指针，指向队首元素
        self._size: int = 0 # 队列长度

    def capacity(self) -> int:
        """获取队列的容量"""
        return len(self._nums)

    def size(self) -> int:
        """获取队列的长度"""
        return self._size

    def is_empty(self) -> bool:
        """判断队列是否为空"""
        return self._size == 0

    def push(self, num: int):
        """ 入队"""
        if self._size == self.capacity():
            raise IndexError(" 队列已满")
        # 计算队尾指针，指向队尾索引 + 1
        # 通过取余操作实现 rear 越过数组尾部后回到头部
        rear: int = (self._front + self._size) % self.capacity()
        # 将 num 添加至队尾
        self._nums[rear] = num
        self._size += 1

    def pop(self) -> int:
        """出队"""
        num: int = self.peek()
        # 队首指针向后移动一位，若越过尾部，则返回到数组头部
        self._front = (self._front + 1) % self.capacity()
        self._size -= 1
        return num

    def peek(self) -> int:
        """访问队首元素"""
        if self.is_empty():
            raise IndexError("队列为空")
        return self._nums[self._front]

    def to_list(self) -> list[int]:
        """返回列表用于打印"""
        res = [0] * self.size()
        j: int = self._front
        for i in range(self.size()):
            res[i] = self._nums[(j % self.capacity())]
            j += 1
        return res

if __name__ == '__main__':
    que = RingQueue(10)
    que.push(1)
    print(que.to_list())
    que.push(2)
    print(que.to_list())
    que.push(3)
    print(que.to_list())
    que.pop()
    que.pop()
    print(que.to_list())
    print(que._nums)

## 执行结果：
# [1]
# [1, 2]
# [1, 2, 3]
# [3]
# [1, 2, 3, 0, 0, 0, 0, 0, 0, 0] (此为原始数据，真正的队列数据通过头指针/size来决定)