二叉树 - Python

介绍

二叉树是一种树形结构，每个节点最多有两个子节点，左子节点和右子节点。在Python中，可以用节点类表示每个节点，以及用二叉树类表示整个树。

节点类

每个节点需要保存它的值（value），以及它的左子节点（left）和右子节点（right），因此它可以定义为如下形式：

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

二叉树类

二叉树类需要保存根节点（root），以及一些对树的操作方法。在这里，我们将实现以下操作：

• 插入节点
• 删除节点
• 先序遍历
• 中序遍历
• 后序遍历
• 层序遍历

class BinaryTree:
    def __init__(self):
        self.root = None
    
    def insert(self, value):
        node = Node(value)
        if not self.root:
            self.root = node
        else:
            queue = [self.root]
            while queue:
                cur = queue.pop(0)
                if not cur.left:
                    cur.left = node
                    return
                elif not cur.right:
                    cur.right = node
                    return
                else:
                    queue.append(cur.left)
                    queue.append(cur.right)
    
    def delete(self, value):
        if not self.root:
            return None
        
        def find_node(node, value):
            if not node:
                return None
            if node.value == value:
                return node
            left_node = find_node(node.left, value)
            if left_node:
                return left_node
            return find_node(node.right, value)
        
        node = find_node(self.root, value)
        if not node:
            return None
        
        queue = [self.root]
        while queue:
            cur = queue.pop(0)
            if cur.left == node:
                cur.left = None
                node = None
                return
            elif cur.right == node:
                cur.right = None
                node = None
                return
            else:
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
    
    def pre_order(self, node):
        if not node:
            return
        print(node.value, end=" ")
        self.pre_order(node.left)
        self.pre_order(node.right)
    
    def in_order(self, node):
        if not node:
            return
        self.in_order(node.left)
        print(node.value, end=" ")
        self.in_order(node.right)
    
    def post_order(self, node):
        if not node:
            return
        self.post_order(node.left)
        self.post_order(node.right)
        print(node.value, end=" ")
    
    def level_order(self):
        if not self.root:
            return
        
        queue = [self.root]
        while queue:
            node = queue.pop(0)
            print(node.value, end=" ")
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

使用示例

# 创建一棵二叉树
tree = BinaryTree()

# 插入节点
tree.insert(1)
tree.insert(2)
tree.insert(3)
tree.insert(4)
tree.insert(5)

# 先序遍历
tree.pre_order(tree.root)

# 删除节点
tree.delete(4)

# 层序遍历
tree.level_order()

结论

二叉树类提供了很多有用的方法，使得操作二叉树变得容易。在实际的应用中，很多问题都可以转换为二叉树的问题，因此掌握二叉树的相关知识是非常重要的。