[python项目案例] 栈的封装、队列封装

一、栈的封装

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

要求功能：以列表作为输入元素，要求有：入栈，出栈，判断栈元素是否为空，求栈顶元素，求栈长度。

class Stack(object):
    """栈的封装[1, 2, 3]"""

    def __init__(self):
        self.stack = []

    def push(self, value):
        """入栈"""
        self.stack.append(value)
        print(f"入栈元素为{value}")

    def pop(self):
        """出栈"""
        if self.is_empty():
            raise  Exception("栈为空")
        item = self.stack.pop()
        print(f"出栈元素为{item}")
        return  item

    def is_empty(self):
        """判断栈是否为空"""
        return  len(self.stack) == 0

    def top(self):
        """返回栈顶元素"""
        if self.is_empty():
            raise  Exception("栈为空")
        return  self.stack[-1]

    def __len__(self):
        """魔术方法, len(object)自动执行的方法"""
        return  len(self.stack)


#测试
if __name__ == '__main__':
    stack = Stack()
    stack.push(1)
    stack.push(2)
    stack.push(3)
    print(len(stack))                     # 3
    stack.pop()
    print(stack.is_empty())               # False
    print(stack.top())                    # 2
#结果
入栈元素为1
入栈元素为2
入栈元素为3
3
出栈元素为3
False
2

Process finished with exit code 0

二、队列的封装

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

要求功能：左侧作为队头，右侧作为队尾
入队，长度，出队，是否为空，队头，队尾。

class Stack(object):
    """队的封装基于列表[1, 2, 3, 4]，左边作为栈底，右边作为栈顶"""

    def __init__(self):
        self.stack = []

    def push(self, value):
        """入队"""
        self.stack.append(value)               #新元素加到最右边
        print(f"入队元素为{value}")

    def pop(self):
        """出队"""
        if self.is_empty():
            raise  Exception("队为空")         #设置出队元素为左边第一个
        item = self.stack.pop(0)
        print(f"出队元素为{item}")
        return  item

    def is_empty(self):
        """判断队是否为空"""
        return  len(self.stack) == 0

    def top(self):
        """队头"""
        if self.is_empty():
            raise  Exception("队为空")
        return  self.stack[0]

    def end(self):
        """队尾"""
        if self.is_empty():
            raise  Exception("队为空")
        return  self.stack[-1]

    def __len__(self):
        """魔术方法, len(object)自动执行的方法"""
        return  len(self.stack)

if __name__ == '__main__':
    stack = Stack()
    stack.push(1)
    stack.push(2)
    stack.push(3)
    print(len(stack))          # 3
    stack.pop()                #出队元素为1
    print(stack.is_empty())    # False
    print(stack.top())         # 2
    print(stack.end())         #3


#结果
入队元素为1
入队元素为2
入队元素为3
3
出队元素为1
False
2
3

Process finished with exit code 0

三、二叉树的封装

"""
二叉树:
    https://www.cnblogs.com/polly333/p/4740355.html
"""

class Node(object):
    """节点类"""
    def __init__(self, val=None, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class BinaryTree(object):
    """封装二叉树"""
    def __init__(self, root):
        self.root = root

    def pre_travel(self, root):
        """先序遍历: 根左右"""
        if (root != None):
            print(root.val)
            self.pre_travel(root.left)
            self.pre_travel(root.right)


    def in_travel(self, root):
        """中序遍历: 左根右"""
        if (root != None):
            self.in_travel(root.left)
            print(root.val)
            self.in_travel(root.right)

    def last_travel(self, root):
        """后序遍历: 左右根"""
        if (root != None):
            self.last_travel(root.left)
            self.last_travel(root.right)
            print(root.val)


if __name__ == '__main__':
    node1 = Node(1)
    node2 = Node(2)
    node3 = Node(3)
    node4 = Node(4)
    node5 = Node(5)
    node6 = Node(6)
    node7 = Node(7)
    node8 = Node(8)
    node9 = Node(9)
    node10 = Node(10)

    bt = BinaryTree(root=node1)
    node1.left = node2
    node1.right = node3
    node2.left = node4
    node2.right= node5
    node3.left = node6
    node3.right = node7
    node4.left = node8
    node4.right = node9
    node5.left = node10


    # 先序遍历
    bt.pre_travel(node1)