关于栈和队列的链式存储

栈的链式存储模型

栈模型的特性：先进入的元素后出
当我们使用链式存储对链表进栈出栈的操作时，我们的表头head会随之发生移动。下面我们可以通过代码演示：

栈的链式存储代码演示：

实现功能：进栈，出栈，判断栈空，查看栈顶元素

"""
创建链式栈
思路：
    1、通过节点存储数据，达到链式存储的目的
    2、封装方法，实现栈的基本操作（入栈，出栈，栈空，查看栈顶）
    3、top为栈顶，在链表的头作为栈顶位置（不需要遍历）
"""


# 创建节点类
class Node:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next


class StackError(Exception):
    pass


# 链式栈模型
class LStack:
    def __init__(self):
        self.__top = None

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

    # 入栈 注意：创建节点后，入栈，栈顶往前移
    def push(self, val):
        node = Node(val)
        node.next = self.__top
        self.__top = node
        # self.__top = Node(val,self.__top)

    # 出栈
    def pop(self):
        if self.is_empty():
            raise StackError("pop from empty stack")
        result = self.__top.val
        self.__top = self.__top.next #元素出栈后，栈顶往后移
        return result

    # 查看栈内元素
    def top(self):
        if self.is_empty():
            raise StackError("pop from empty stack")
        return self.__top.val


if __name__ == "__main__":
    ls = LStack()
    ls.push(10)
    ls.push(15)
    ls.push(20)
    ls.push(25)
    print(ls.pop())
    print(ls.pop())

在入栈时，创建节点，节点与栈顶元素建立链接，栈顶移动至节点
node = Node(value) # 创建节点
node.next = self.top # 节点与栈顶元素建立链接
self.top = node # 栈顶移动至入栈元素

在出栈时，元素出栈，返回出栈元素的值，栈顶往栈底移动

当栈内没有任何元素，self.top = None，则判断栈为空。

队列的链式存储

特点：先进入队列的元素，先出
能够对链式队列进行操作的地方有两个，队头，队尾。
如何判断队列为空队列，我们可以创建队头，队尾的节点，当队头，队尾指向同一元素的时候，我们判断队列为空。

链式队列的代码演示：

"""
链式队列
思路：
    1、基于链表构建队列模型
    2、链表的开端作为队头，结尾作为队尾
    3、采用双标记，队头、队尾分别添加标记，
        避免每次插入数据都遍历链表
    4、队头队尾重叠时，队列为空。
"""


# 创建节点类
class Node:
    """
    自定义类视为节点类，属性作为数据内容
    写一个next属性，用来和下一个节点创建联系
    """

    def __init__(self, val, next=None):
        """
        :param val:必要数据
        :param next:下个节点的引用
        """
        self.val = val
        self.next = next


class QueueError(Exception):
    pass


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

    def is_empyt(self):
        return self.front == self.rear

    def enqueue(self, value): # 入队时，我们只对队尾进行操作，每入队一个元素，队尾往后移
        node = Node(value)
        self.rear.next = node
        self.rear = self.rear.next

    def dequeue(self):
        if self.is_empyt():
            raise QueueError("Queue is empty")
        # front移动到的节点已经出队
        self.front = self.front.next
        return self.front.val


if __name__ == "__main__":
    lq = LQueue()
    lq.enqueue(10)
    lq.enqueue(15)
    lq.enqueue(20)
    lq.enqueue(25)
    print(lq.dequeue())