树形结构进阶：从入门到实践-原创手记-慕课网

本文深入探讨了树形结构的基础知识，包括定义、表示方法和常见类型。文章还详细介绍了树的遍历方法和常用操作算法，并通过实际应用案例展示了树形结构在文件系统、HTML文档和数据库中的应用。此外，文章还提供了树形结构进阶优化技巧，如平衡树的构建与维护、树的压缩与展开，以及如何选择合适的树形结构类型。

树形结构基础回顾

树的定义与基本概念

树是一种非线性的数据结构，它由若干个结点（Node）组成，每个结点可以包含一个数据元素和若干指向其他结点的引用。树的结构如下：

根结点（Root Node）：树中唯一的一个没有父节点的结点。
内部结点（Internal Node）：至少有一个子节点的结点。
叶子结点（Leaf Node）：没有子节点的结点。
子结点（Child Node）：如果一个结点含有子节点，则这些子节点称为该结点的子结点。
父结点（Parent Node）：一个结点的子节点的父节点是该结点本身。
兄弟结点（Sibling Node）：同一父节点下的结点之间的关系。
路径（Path）：从一个结点到另一个结点的连接线段，路径上的结点数量称为路径的长度。
层次（Level）：根结点的层次为1，对于其他结点，其层次等于其父结点的层次加1。
高度（Height）：树中结点的最大层次数。
度（Degree）：一个结点的子节点数称为该结点的度，树中的结点的最大度称为树的度。

树的定义不仅限于二叉树，还可以是任意多叉树。树具有递归结构，可以通过递归算法进行处理。

树的表示方法

树的表示方法主要有以下几种：

图形表示法：通过图形直观地展示树的结构。

Root
├── Child 1
│   ├── Child 1.1
│   └── Child 1.2
└── Child 2
    └── Child 2.1

集合表示法：使用集合来表示树中的结点和边。

tree = {
    'Root': {'Child 1', 'Child 2'},
    'Child 1': {'Child 1.1', 'Child 1.2'},
    'Child 2': {'Child 2.1'}
}

数组表示法：使用数组来表示树的结构。

class TreeNode:
    def __init__(self, val, children=None):
        self.val = val
        self.children = children or []

tree = TreeNode('Root')
tree.children.append(TreeNode('Child 1'))
tree.children[0].children.append(TreeNode('Child 1.1'))
tree.children[0].children.append(TreeNode('Child 1.2'))
tree.children.append(TreeNode('Child 2'))
tree.children[1].children.append(TreeNode('Child 2.1'))

链表表示法：使用链表来表示树的结构。

class Node:
    def __init__(self, val, children=None):
        self.val = val
        self.children = children or []

tree = Node('Root')
tree.children = [Node('Child 1')]
tree.children[0].children = [Node('Child 1.1'), Node('Child 1.2')]
tree.children.append(Node('Child 2'))
tree.children[1].children = [Node('Child 2.1')]

常见的树形结构类型

二叉树（Binary Tree）：每个结点最多有两个子节点，分别称为左子节点和右子节点。

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

多叉树（n-ary Tree）：每个结点可以有任意数量的子节点。

class TreeNode:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children or []

root = TreeNode(1)
root.children = [TreeNode(2), TreeNode(3)]
root.children[0].children = [TreeNode(4), TreeNode(5)]

平衡树（Balanced Tree）：树的任意两个叶子结点的深度差不超过1，常见的平衡树有AVL树和红黑树。

class AVLNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None
        self.height = 1

def insert(root, key):
    if not root:
        return AVLNode(key)
    elif key < root.val:
        root.left = insert(root.left, key)
    else:
        root.right = insert(root.right, key)

    root.height = 1 + max(get_height(root.left), get_height(root.right))
    balance = get_balance(root)

    if balance > 1 and key < root.left.val:
        return right_rotate(root)
    if balance < -1 and key > root.right.val:
        return left_rotate(root)
    if balance > 1 and key > root.left.val:
        root.left = left_rotate(root.left)
        return right_rotate(root)
    if balance < -1 and key < root.right.val:
        root.right = right_rotate(root.right)
        return left_rotate(root)

    return root

def get_height(node):
    if not node:
        return 0
    return node.height

def get_balance(node):
    if not node:
        return 0
    return get_height(node.left) - get_height(node.right)

完全二叉树（Complete Binary Tree）：除了最后一层，每层的结点数都是满的，最后一层的结点尽可能靠左填充。

from collections import deque

def is_complete_binary_tree(root):
    if not root:
        return True

    queue = deque([root])
    is_leaf = False

    while queue:
        node = queue.popleft()

        if node.left:
            if is_leaf:
                return False
            queue.append(node.left)
        else:
            is_leaf = True

        if node.right:
            if is_leaf:
                return False
            queue.append(node.right)
        else:
            is_leaf = True

    return True

满二叉树（Full Binary Tree）：每个结点要么有0个子节点，要么有2个子节点。

def is_full_binary_tree(root):
    if not root:
        return True

    if not root.left and not root.right:
        return True

    if root.left and root.right:
        return is_full_binary_tree(root.left) and is_full_binary_tree(root.right)

    return False

树的遍历方法详解

树的遍历方法主要有以下几种：

前序遍历（Preorder Traversal）：访问根结点，然后递归地前序遍历左子树，最后递归地前序遍历右子树。

def pre_order_traversal(root):
    if root:
        print(root.val, end=" ")
        pre_order_traversal(root.left)
        pre_order_traversal(root.right)

假设我们有一个二叉树实例：

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

pre_order_traversal(root)

中序遍历（Inorder Traversal）：递归地中序遍历左子树，访问根结点，然后递归地中序遍历右子树。

def in_order_traversal(root):
    if root:
        in_order_traversal(root.left)
        print(root.val, end=" ")
        in_order_traversal(root.right)

继续使用上面的二叉树实例：

in_order_traversal(root)

后序遍历（Postorder Traversal）：递归地后序遍历左子树，递归地后序遍历右子树，然后访问根结点。

def post_order_traversal(root):
    if root:
        post_order_traversal(root.left)
        post_order_traversal(root.right)
        print(root.val, end=" ")

继续使用上面的二叉树实例：

post_order_traversal(root)

层次遍历（Level Order Traversal）：从根结点开始，按层次遍历树，每一层从左到右依次遍历。

def level_order_traversal(root):
    if not root:
        return

    queue = deque([root])

    while queue:
        node = queue.popleft()
        print(node.val, end=" ")

        if node.left:
            queue.append(node.left)

        if node.right:
            queue.append(node.right)

继续使用上面的二叉树实例：

level_order_traversal(root)

操作树的常用算法

插入节点

插入节点的方法取决于树的类型。以下是二叉树插入节点的示例：

def insert(root, key):
    if not root:
        return TreeNode(key)
    elif key < root.val:
        root.left = insert(root.left, key)
    else:
        root.right = insert(root.right, key)
    return root

假设我们有一个二叉树实例：

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

insert(root, 6)

插入节点后，树结构变为：

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.left.right.right = TreeNode(6)

删除节点

删除节点的方法也取决于树的类型。以下是二叉树删除节点的示例：

def delete(root, key):
    if not root:
        return root

    if key < root.val:
        root.left = delete(root.left, key)
    elif key > root.val:
        root.right = delete(root.right, key)
    else:
        if not root.left:
            return root.right
        if not root.right:
            return root.left

        temp = find_min(root.right)
        root.val = temp.val
        root.right = delete(root.right, temp.val)

    return root

def find_min(node):
    while node.left:
        node = node.left
    return node

假设我们有一个二叉树实例：

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

delete(root, 2)

删除节点后，树结构变为：

root = TreeNode(1)
root.left = TreeNode(4)
root.right = TreeNode(3)
root.left.right = TreeNode(5)

查找节点

查找节点的方法也取决于树的类型。以下是二叉树查找节点的示例：

def search(root, key):
    if not root or root.val == key:
        return root

    if key < root.val:
        return search(root.left, key)
    return search(root.right, key)

假设我们有一个二叉树实例：

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

search(root, 2)

树形结构的实际应用

文件系统中的树形结构

文件系统中的文件和文件夹可以表示为一棵树，根结点是根目录，每个文件夹和文件都是树的结点。

class TreeNode:
    def __init__(self, name, children=None):
        self.name = name
        self.children = children or []

def create_file_tree():
    root = TreeNode('/')
    root.children.append(TreeNode('usr'))
    root.children[0].children.append(TreeNode('bin'))
    root.children[0].children[0].children.append(TreeNode('ls'))
    root.children.append(TreeNode('etc'))
    root.children[1].children.append(TreeNode('hosts'))
    return root

创建文件树实例后，树结构如下：

root = create_file_tree()

HTML文档树

HTML文档可以表示为一棵树，每个标签都是树的结点。

<!DOCTYPE html>
<html>
<head>
    <title>HTML Document Tree</title>
</head>
<body>
    <h1>Header</h1>
    <p>This is a paragraph.</p>
    <ul>
        <li>Item 1</li>
        <li>Item 2</li>
    </ul>
</body>
</html>

将HTML文档转换为树结构的Python代码如下：

from bs4 import BeautifulSoup

def parse_html_tree(html_content):
    soup = BeautifulSoup(html_content, 'html.parser')
    root = TreeNode('html')
    root.children.append(TreeNode('head'))
    root.children[0].children.append(TreeNode('title'))
    root.children[0].children[0].val = 'HTML Document Tree'
    root.children.append(TreeNode('body'))
    root.children[1].children.append(TreeNode('h1'))
    root.children[1].children[0].val = 'Header'
    root.children[1].children.append(TreeNode('p'))
    root.children[1].children[1].val = 'This is a paragraph.'
    root.children[1].children.append(TreeNode('ul'))
    root.children[1].children[2].children.append(TreeNode('li'))
    root.children[1].children[2].children[0].val = 'Item 1'
    root.children[1].children[2].children.append(TreeNode('li'))
    root.children[1].children[2].children[1].val = 'Item 2'
    return root

html_content = """
<!DOCTYPE html>
<html>
<head>
    <title>HTML Document Tree</title>
</head>
<body>
    <h1>Header</h1>
    <p>This is a paragraph.</p>
    <ul>
        <li>Item 1</li>
        <li>Item 2</li>
    </ul>
</body>
</html>
"""

tree = parse_html_tree(html_content)

数据库中的B树

数据库中的索引可以使用B树来实现，B树是一种平衡的多叉树，每个结点可以存储多个键值对。

class BTreeNode:
    def __init__(self, leaf=False):
        self.keys = []
        self.children = []
        self.leaf = leaf

def insert_btree(root, key):
    if not root:
        return BTreeNode()

    if root.leaf:
        root.keys.append(key)
        root.keys.sort()
    else:
        i = 0
        while i < len(root.keys):
            if key < root.keys[i]:
                child = insert_btree(root.children[i], key)
                if child:
                    root.children.insert(i + 1, child)
                    root.keys.insert(i, key)
                    if len(root.keys) > 2:
                        split_btree(root)
                    break
            i += 1
        if i == len(root.keys):
            child = insert_btree(root.children[i], key)
            if child:
                root.children.append(child)
            if len(root.keys) > 2:
                split_btree(root)

def split_btree(node):
    mid = len(node.keys) // 2
    new_node = BTreeNode(leaf=node.leaf)
    new_node.keys = node.keys[mid + 1:]
    new_node.children = node.children[mid + 1:]
    node.keys = node.keys[:mid]
    node.children = node.children[:mid + 1]
    return new_node

插入B树实例后，树结构如下：

root = insert_btree(None, 1)
root = insert_btree(root, 2)
root = insert_btree(root, 3)
root = insert_btree(root, 4)
root = insert_btree(root, 5)

树形结构优化技巧

平衡树的构建与维护

平衡树的构建与维护可以通过旋转操作来实现，例如AVL树和红黑树。

def left_rotate(node):
    new_root = node.right
    node.right = new_root.left
    new_root.left = node
    node.height = 1 + max(get_height(node.left), get_height(node.right))
    new_root.height = 1 + max(get_height(new_root.left), get_height(new_root.right))
    return new_root

def right_rotate(node):
    new_root = node.left
    node.left = new_root.right
    new_root.right = node
    node.height = 1 + max(get_height(node.left), get_height(node.right))
    new_root.height = 1 + max(get_height(new_root.left), get_height(new_root.right))
    return new_root

def insert_avl(root, key):
    if not root:
        return AVLNode(key)

    if key < root.val:
        root.left = insert_avl(root.left, key)
    else:
        root.right = insert_avl(root.right, key)

    root.height = 1 + max(get_height(root.left), get_height(root.right))
    balance = get_balance(root)

    if balance > 1 and key < root.left.val:
        return right_rotate(root)
    if balance < -1 and key > root.right.val:
        return left_rotate(root)
    if balance > 1 and key > root.left.val:
        root.left = left_rotate(root.left)
        return right_rotate(root)
    if balance < -1 and key < root.right.val:
        root.right = right_rotate(root.right)
        return left_rotate(root)

    return root

插入AVL树实例后，树结构如下：

root = AVLNode(1)
root = insert_avl(root, 2)
root = insert_avl(root, 3)
root = insert_avl(root, 4)
root = insert_avl(root, 5)

树的压缩与展开

树的压缩可以通过删除冗余节点来实现，树的展开可以通过插入新节点来实现。

def compress_tree(root):
    if not root:
        return None

    if not root.left and not root.right:
        return None

    root.left = compress_tree(root.left)
    root.right = compress_tree(root.right)

    if not root.left and not root.right:
        return None

    return root

def expand_tree(root):
    if not root:
        return None

    if not root.left:
        root.left = TreeNode(root.val)
        root.val = root.left.val

    if not root.right:
        root.right = TreeNode(root.val)
        root.val = root.right.val

    expand_tree(root.left)
    expand_tree(root.right)

    return root

压缩和展开树实例后，树结构如下：

root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

# Compress tree
compressed_root = compress_tree(root)
# Expand tree
expanded_root = expand_tree(root)

选择合适的树形结构类型

选择合适的树形结构类型取决于应用场景和需求。例如，如果需要快速插入和删除操作，可以使用AVL树或红黑树。如果需要快速查找操作，可以使用B树。如果需要实现文件系统或HTML文档，可以使用多叉树。

def choose_tree_type(operation):
    if operation in ['insert', 'delete']:
        return 'AVL Tree'
    elif operation == 'search':
        return 'B Tree'
    elif operation == 'file_system':
        return 'n-ary Tree'
    elif operation == 'html_document':
        return 'n-ary Tree'

总结来说，树形结构是计算机科学中非常重要的数据结构，理解树形结构的基础概念和操作方法是进一步学习高级数据结构和算法的基石。通过实际应用案例和优化技巧的学习，可以帮助我们更好地理解和应用树形结构。