Python-栈的封装，队列的封装，二叉树的封装

项目案例：栈的封装

class Stack:
    """栈的封装"""
    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}")

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

执行结果如下：

项目案例：队列的封装

class Queue:
    def __init__(self):
        self.queue = []

    def enqueue(self,value):
        #入队
        self.queue.append(value)
        print(f'进入队列的是{value}')

    def dequeue(self):
        #出队
        if len(self.queue) == 0:
            raise Exception('队列长度为0')
        item = self.queue.pop(0)
        print(f'出队列的是{item}')

    def is_empty(self):
        #判断是否为空
        return len(self.queue) == 0

    def __len__(self):
        #魔术方法：获取队列长度
        return len(self.queue)

    def first(self):
        #获取队头元素
        if len(self.queue) == 0:
            raise Exception('队列长度为0')
        return self.queue[0]

    def last(self):
        #获取队尾元素
        if len(self.queue) == 0:
            raise Exception('队列长度为0')
        return self.queue[-1]

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

执行结果如下：

二叉树的封装

class Node:
#节点的封装
    def __init__(self,value=None,left=None,right=None):
        self.value = value
        self.left = left
        self.right = right


class Bt:
    def __init__(self,root):
        self.root = root

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


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 = Bt(root=node1)
    node1.left = node2
    node2.left = node4
    node4.left = node8
    node4.right = node9
    node2.right = node5
    node5.left = node10
    node1.right = node3
    node3.left = node6
    node3.right = node7

   #先序遍历
    bt.pre_travel(root=node1)

拓展：

#接上文，中序遍历，左根右
    def in_travel(self,root):
        if root != None:
            self.in_travel(root.left)
            print(root.value)
            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.value)