python栈与队列的封装

项目案例一：栈的封装

• 栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中没有元素时称为“空栈”。向一个栈内插入元素称为是进栈，push；从一个栈删除元素称为是出栈，pop。
• 特点 ：后进先出（LIFO）。
  
  代码：

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()
        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))
    stack.pop()
    print(stack.is_empty())
    print(stack.top())

代码运行结果：

项目案例: 队列的封装

• 队列是限制在一端进行插入操作和另一端删除操作的线性表，允许进行插入操作的一端称为“队尾”，允许进行删除操作的一端称为“队头”
  ，当队列中没有元素时称为“空队”。
• 特点 ：先进先出（FIFO）。

class Queue(object):
    """队列的封装[1,2,3,4]
    1.列表的左侧为队尾
    2.列表的右侧为队头
    """
    def __init__(self):
        self.queue = []

    def enqueue(self,value):
        """入队"""
        self.queue.insert(0,value)
        print(f"入队元素是{value}")
    def dequeue(self):
        """出队"""
        if self.is_empty():
            raise Exception('队列为空')
        item = self.queue.pop()
        print("出队元素为{item}")
        return item
    def __len__(self):
        """获取队列的长度"""
        return len(self.queue)
    def first(self):
        """返回队头元素"""
        if self.is_empty():
            raise Exception('队列为空')
        return self.queue[-1]
    def is_empty(self):
        """判断栈是否为空"""
        return len(self.queue) == 0
    def last(self):
        """获取队尾元素"""
        if self.is_empty():
            raise Exception('队列为空')
        return self.queue[0]

if __name__ == '__main__':
    queue = Queue()
    queue.enqueue(1)
    queue.enqueue(2)
    queue.enqueue(3)
    print(queue.is_empty())
    queue.dequeue()
    print(queue.first())
    print(queue.last())

代码运行结果：

项目案例：二叉树的封装

参考博客： 二叉树封装

二叉树是树的特殊一种，具有如下特点：1、每个结点最多有两颗子树，结点的度最大为2。2、左子树和右子树是有顺序的，次序不能颠倒。3、即使某结点只有一个子树，也要区分左右子树。

"""
二叉树:
"""

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)

遍历结果：