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())

 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章