Python之数据结构--栈和队列

栈和队列

    栈

        1. 定义

            栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，另一固定端称为“栈             底”，当栈中没有元素时称为“空栈”。

        2. 特点：

            栈只能在一端进行数据操作

            栈模型具有先进后出或者叫做后进先出的规律

            

        3. 栈的代码实现

            栈的操作有入栈（压栈），出栈（弹栈），判断栈的空满等操作。

顺序存储代码实现：

"""
    (重点)栈的顺序存储结构
"""


class StackError(Exception):
    pass


class SStack:
    def __init__(self):
        self._elements = []

    # 返回栈顶元素
    def top(self):
        if not self._elements:
            raise StackError("stack is empty")
        return self._elements[-1]

    # 是否为空
    def is_empty(self):
        return self._elements == []

    # 入栈
    def push(self, elem):
        self._elements.append(elem)

    # 出栈
    def pop(self):
        if not self._elements:
            raise StackError("stack is empty")
        return self._elements.pop()

    # 检查指定内容中括号是否匹配
    def check_bracket(self, value):
        role = {'(': ')', '[': ']', '{': '}'}
        if len(value) > 0:
            for c in value:
                if c in "([{":
                    self.push(c)
                elif c in ")]}":
                    try:
                        temp = self.pop()
                        if c == role[temp]:
                            continue
                        else:
                            return False
                    except StackError:
                        return False
            if len(self._elements):
                return False
            return True
        else:
            raise StackError("txt is empty")


if __name__ == '__main__':
    stack = SStack()
    txt = "{(这)是一个(有趣)的[故事]}"
    print(stack.check_bracket(txt))

链式存储代码实现：

"""
    (重点)栈的链式存储结构
"""


class StackError(Exception):
    pass


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

    def __str__(self):
        return str(self.name)


class LStack:
    def __init__(self):
        self._top = None

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

    def push(self, value):
        self._top = Node(value, self._top)

    def pop(self):
        p = self._top
        self._top = p.next
        return p

    def top(self):
        if not self._top:
            raise StackError("stack is empty")
        return self._top


if __name__ == '__main__':
    stack = LStack()
    stack.push(10)
    stack.push(20)
    print(stack.top())

    队列

         1. 定义

             队列是限制在两端进行插入操作和删除操作的线性表，允许进行存入操作的一端称为“队尾”，允许进行删除操作的一端称为“队头”。

        2. 特点：

            队列只能在队头和队尾进行数据操作

            队列模型具有先进先出或者叫做后进后出的规律

          

       3. 队列的代码实现

            队列的操作有入队，出队，判断队列的空满等操作。

顺序存储代码实现： 

"""
    顺序队列
"""


class QueueError(Exception):
    pass


class SSqueue:
    def __init__(self):
        self._elements = []

    # 清空队列
    def clear(self):
        self._elements = []

    # 是否为空
    def is_empty(self):
        return self._elements == []

    # 入队
    def enqueue(self, value):
        self._elements.append(value)

    # 出队
    def dequeue(self):
        if not self._elements:
            raise QueueError("queue is empty")
        return self._elements.pop(0)


if __name__ == '__main__':
    queue = SSqueue()
    queue.enqueue(1)
    queue.enqueue(2)
    queue.enqueue(3)
    queue.enqueue(4)
    while not queue.is_empty():
        print(queue.dequeue())

链式存储代码实现：

"""
    队列链式存储
"""


class Node:
    def __init__(self, value, n=None):
        self.name = value
        self.next = n


class LQueue:
    def __init__(self):
        self.head = self.end = Node(None)

    # 入队
    def enqueue(self, value):
        self.end.next = Node(value)
        self.end = self.end.next

    # 出队
    def dequeue(self):
        self.head = self.head.next
        return self.head.name

    # 清队
    def clear(self):
        self.end = self.head

    # 是否为空
    def is_empty(self):
        return self.head == self.end

    def length(self):
        length = 0
        p = self.head
        while p.next:
            length += 1
            p = p.next
        return length


if __name__ == '__main__':
    queue = LQueue()
    queue.enqueue(1)
    queue.enqueue(2)
    queue.enqueue(3)
    print(queue.is_empty())
    print(queue.length())
    while queue.head != queue.end:
        print(queue.dequeue())