首页手记树形结构进阶：从入门到实践

树形结构进阶：从入门到实践

标签：

算法与数据结构

本文深入探讨了树形结构的基础知识，包括定义、表示方法和常见类型。文章还详细介绍了树的遍历方法和常用操作算法，并通过实际应用案例展示了树形结构在文件系统、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'

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

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

萧十郎

手记
篇

粉丝

36

获赞与收藏

166

关注作者，订阅最新文章

相关文章推荐

【必备干货】Java从入门到进阶架构师，照着这个路线学习妥妥的！

初探Electron，从入门到实践

GraphQL 从入门到实践

线段树--从入门到精通

精讲Spring Boot—— 入门+进阶+实例

阅读免费教程

后端通用面试教程

41个小节 30273 342

网络编程入门教程

20个小节 12461 235

Pandas 入门教程

25个小节 18362 330

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

树形结构进阶：从入门到实践

树形结构基础回顾

树的定义与基本概念

树的表示方法

常见的树形结构类型

树的遍历方法详解

操作树的常用算法

插入节点

删除节点

查找节点

树形结构的实际应用

文件系统中的树形结构

HTML文档树

数据库中的B树

树形结构优化技巧

平衡树的构建与维护

树的压缩与展开

选择合适的树形结构类型

相关文章推荐

阅读免费教程