为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 树形结构学习：从入门到实践的简单教程

树形结构学习：从入门到实践的简单教程

标签：
机器学习 人工智能 算法与数据结构
概述

本文详细介绍了树形结构的基本概念和操作，包括树的定义、分类、表示方法以及基本操作如插入、删除和查找节点。文章还探讨了树的遍历方法和应用场景，如文件系统、HTML文档树和数据库索引。此外，文中还涉及了树形结构学习的相关优化和扩展方法，如平衡二叉树、B树和Trie树。

树形结构简介

树是一种非线性的数据结构，广泛应用于各种计算机科学领域，包括操作系统、数据库、文件系统、网络路由和数据分析等。树的定义是从一个根节点出发，通过一系列连接到其他节点的边构成的一个无环、连通的图。

树的基本概念

树是一组节点的集合，每个节点都有一个唯一的父节点，除了根节点外，每一个节点都有一个父节点。树的根节点没有父节点，所有其他节点都只有一个父节点，并且只有一个路径从根节点到达每一个节点。树的节点也可以有多个子节点，每个子节点又可以有多个子节点，以此类推，形成层次结构。

定义一个简单的树结构时，通常定义一个节点类，包含节点的信息和指向其子节点的指针。

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

树与二叉树的区别

树和二叉树都是数据结构，但两者存在一些关键的区别。

  • 定义：树是一种数据结构，其中每个节点可以有任意数量的子节点，而二叉树则规定每个节点最多有两个子节点。
  • 存储：树通常用于表示任意的层次结构，而二叉树在很多算法中被用来进行高效的查找和排序。
  • 操作效率：在处理特定问题时，二叉树的某些操作（如插入、查找和删除）可能比一般树更高效。

树的分类介绍

树有许多不同的类型，每种类型的树都适用于特定的应用场景。

  • 普通树：每个节点可以有任意数量的子节点。例如，一个简单的普通树结构可以是：

    class TreeNode:
  def __init__(self, value):
      self.value = value
      self.children = []

root = TreeNode(1)
child1 = TreeNode(2)
child2 = TreeNode(3)
root.children.append(child1)
root.children.append(child2)
  • 二叉树：每个节点最多有两个子节点，即左子节点和右子节点。
  • 满二叉树：所有叶子节点都在同一层，且所有非叶子节点都有两个子节点。
  • 完全二叉树：除了最后一层，所有层都充满了节点，并且最后一层的节点都靠左。
  • 二叉搜索树（BST）：二叉树中每个节点的左子树中的值都小于该节点的值，右子树中的值都大于该节点的值。

树的表示方法

树的表示方法主要有两种：数组表示方法和链表表示方法。

使用数组表示树

数组表示树的方法是一种高效的方法，但只适用于完全二叉树。在数组中，节点的索引可以用来确定其父节点和子节点的位置。

假设根节点索引为0，对于任意一个索引为i的节点：

  • 其左子节点的索引为2*i + 1
  • 其右子节点的索引为2*i + 2
  • 其父节点的索引为(i - 1) // 2
def get_left_child_index(i):
    return 2 * i + 1

def get_right_child_index(i):
    return 2 * i + 2

def get_parent_index(i):
    return (i - 1) // 2

使用链表表示树

链表表示树的方法指的是每个节点都有指向其子节点的指针。链表表示法更灵活，可以处理任意树（包括非完全二叉树）。

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

# 创建一个简单的树
root = TreeNode(1)
child1 = TreeNode(2)
child2 = TreeNode(3)
root.children.append(child1)
root.children.append(child2)

树的基本操作

树的基本操作包括插入节点、删除节点和查找节点。

插入节点

插入一个新节点时，需要找到正确的父节点，并将新节点添加为其子节点。

def insert_node(parent, value):
    new_node = TreeNode(value)
    parent.children.append(new_node)
    return new_node

删除节点

删除一个节点时，需要删除该节点及其所有子节点，并更新其父节点的指针。

def delete_node(node):
    parent = node.parent
    if parent:
        parent.children.remove(node)
        node.parent = None
    for child in node.children:
        child.parent = parent
    node.children = []

查找节点

查找一个节点时，可以使用递归或者迭代的方法。

def find_node(root, value):
    if root.value == value:
        return root
    for child in root.children:
        found = find_node(child, value)
        if found:
            return found
    return None

树的遍历方法

树的遍历方法包括前序遍历、中序遍历、后序遍历和层次遍历。

前序遍历

前序遍历按根节点、左子树、右子树的顺序访问节点。

def preorder_traversal(root):
    if root:
        print(root.value)
        for child in root.children:
            preorder_traversal(child)

中序遍历

中序遍历按左子树、根节点、右子树的顺序访问节点。

def inorder_traversal(root):
    if root:
        for child in root.children:
            inorder_traversal(child)
        print(root.value)

后序遍历

后序遍历按左子树、右子树、根节点的顺序访问节点。

def postorder_traversal(root):
    if root:
        for child in root.children:
            postorder_traversal(child)
        print(root.value)

层次遍历

层次遍历按层次顺序访问节点，从根节点开始，逐层访问每个节点。

def level_order_traversal(root):
    if not root:
        return
    queue = [root]
    while queue:
        node = queue.pop(0)
        print(node.value)
        queue.extend(node.children)

树的应用场景

树在计算机科学中有很多实际应用，包括文件系统中的树形结构、HTML文档树、导航菜单设计和数据库索引。

文件系统中的树形结构

文件系统通常使用树形结构来组织文件和目录，根目录是树的根节点，其他目录和文件是根节点的子节点。

# 示例：创建一个简单的树形文件系统
class TreeNode:
    def __init__(self, value):
        self.value = value
        self.children = []

root = TreeNode('/')
dir1 = TreeNode('dir1')
dir2 = TreeNode('dir2')
root.children.append(dir1)
root.children.append(dir2)
file1 = TreeNode('file1.txt')
file2 = TreeNode('file2.txt')
dir1.children.append(file1)
dir2.children.append(file2)

HTML文档树

HTML文档树是一种树形结构，其中每个元素节点都有一个父节点和可能的子节点。

# 示例：解析HTML文档树
from bs4 import BeautifulSoup

html_doc = """
<html>
<head>
    <title>Example</title>
</head>
<body>
    <h1>Header</h1>
    <p>Paragraph 1</p>
    <div>
        <p>Paragraph 2</p>
    </div>
</body>
</html>
"""

soup = BeautifulSoup(html_doc, 'html.parser')

def traverse_tree(node, depth=0):
    print(' ' * depth + node.name)
    for child in node.children:
        traverse_tree(child, depth + 1)

root = soup.html
traverse_tree(root)

导航菜单设计

导航菜单设计通常使用树形结构来表示不同级别的菜单项及其子项。

menu = {
    "Home": {
        "About": {
            "Mission": None,
            "Vision": None
        },
        "Contact": None
    },
    "Products": {
        "Product1": None,
        "Product2": None
    }
}

# 示例：生成导航菜单
from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('menu.html', menu=menu)

if __name__ == '__main__':
    app.run(debug=True)

数据库索引

数据库索引通常使用树形结构来提高查询效率，例如B树和B+树。

# 示例：创建一个B树索引
class Node:
    def __init__(self, keys, children):
        self.keys = keys
        self.children = children

class BTree:
    def __init__(self, t):
        self.root = Node([], [])
        self.t = t

    def insert(self, key):
        if len(self.root.keys) == (2 * self.t) - 1:
            new_root = Node([self.root.keys[0]], [self.root, Node([], [])])
            self.root = new_root
            self.split_child(new_root, 0)
        else:
            self.root.insert(key)

    def split_child(self, node, index):
        new_node = Node([], node.children[index].children[1:])
        mid = self.t - 1
        node.keys.insert(index, node.children[index].keys[mid])
        node.children.insert(index + 1, new_node)
        node.children[index].keys = node.children[index].keys[:mid]
        node.children[index].children = node.children[index].children[:mid]

# 示例：创建一个B+树索引
class BPlusNode:
    def __init__(self, t):
        self.keys = []
        self.pointers = []
        self.leaf = False
        self.t = t

    def insert(self, key, value):
        i = len(self.keys) - 1
        while i >= 0 and key < self.keys[i]:
            i -= 1
        if self.leaf:
            self.keys.insert(i + 1, key)
            self.pointers.insert(i + 1, value)
        else:
            if len(self.keys) < 2 * self.t - 1:
                self.keys.insert(i + 1, key)
                self.pointers.insert(i + 1, value)
            else:
                self.keys.insert(i + 1, key)
                self.pointers.insert(i + 1, value)
                self.split(i + 1)

    def split(self, index):
        new_node = BPlusNode(self.t)
        new_node.leaf = self.leaf
        new_node.keys = self.keys[self.t:]
        new_node.pointers = self.pointers[self.t + 1:]
        self.keys = self.keys[:self.t]
        self.pointers = self.pointers[:self.t]
        if index < len(self.pointers):
            self.pointers[index] = new_node
        else:
            self.pointers.append(new_node)

树的优化与扩展

树的优化与扩展方法包括平衡二叉树、B树和B+树、Trie树等。

平衡二叉树

平衡二叉树是一种自平衡的查找树，其左子树和右子树的高度差不超过1。常见的平衡二叉树包括AVL树和红黑树。

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

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)

def rotate_right(z):
    y = z.left
    T2 = y.right
    y.right = z
    z.left = T2
    z.height = 1 + max(get_height(z.left), get_height(z.right))
    y.height = 1 + max(get_height(y.left), get_height(y.right))
    return y

def rotate_left(z):
    y = z.right
    T2 = y.left
    y.left = z
    z.right = T2
    z.height = 1 + max(get_height(z.left), get_height(z.right))
    y.height = 1 + max(get_height(y.left), get_height(y.right))
    return y

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

    node.height = 1 + max(get_height(node.left), get_height(node.right))

    balance = get_balance(node)

    if balance > 1 and key < node.left.key:
        return rotate_right(node)
    if balance < -1 and key > node.right.key:
        return rotate_left(node)
    if balance > 1 and key > node.left.key:
        node.left = rotate_left(node.left)
        return rotate_right(node)
    if balance < -1 and key < node.right.key:
        node.right = rotate_right(node.right)
        return rotate_left(node)

    return node

B树和B+树

B树和B+树是用于数据库索引的树形结构。B树是一种自平衡的查找树，允许每个节点有多个子节点，B+树是一种优化的B树，所有数据都被存储在叶子节点中。

# 示例：创建一个简单的B树索引
class BTreeNode:
    def __init__(self, t):
        self.keys = []
        self.children = []
        self.leaf = False
        self.t = t

    def insert(self, key):
        i = len(self.keys) - 1
        while i >= 0 and key < self.keys[i]:
            i -= 1
        self.keys.insert(i + 1, key)

    def split(self, i):
        new_node = BTreeNode(self.t)
        self.keys = self.keys[:self.t - 1]
        self.children = self.children[:self.t]
        new_node.keys = self.keys[self.t:]
        new_node.children = self.children[self.t + 1:]
        self.keys.insert(i, new_node.keys.pop(0))
        self.children.insert(i + 1, new_node)
        return new_node

# 示例：创建一个简单的B+树索引
class BPlusNode:
    def __init__(self, t):
        self.keys = []
        self.pointers = []
        self.leaf = False
        self.t = t

    def insert(self, key, value):
        i = len(self.keys) - 1
        while i >= 0 and key < self.keys[i]:
            i -= 1
        if self.leaf:
            self.keys.insert(i + 1, key)
            self.pointers.insert(i + 1, value)
        else:
            if len(self.keys) < 2 * self.t - 1:
                self.keys.insert(i + 1, key)
                self.pointers.insert(i + 1, value)
            else:
                self.keys.insert(i + 1, key)
                self.pointers.insert(i + 1, value)
                self.split(i + 1)

    def split(self, i):
        new_node = BPlusNode(self.t)
        new_node.keys = self.keys[self.t:]
        new_node.pointers = self.pointers[self.t + 1:]
        self.keys = self.keys[:self.t]
        self.pointers = self.pointers[:self.t]
        if i < len(self.pointers):
            self.pointers[i] = new_node
        else:
            self.pointers.append(new_node)

Trie树

Trie树是一种树形结构，用于存储字符串的关键字。每个节点表示一个字符，所有从根到叶子节点的路径表示一个字符串。

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end_of_word = False

def insert(root, word):
    node = root
    for char in word:
        if char not in node.children:
            node.children[char] = TrieNode()
        node = node.children[char]
    node.is_end_of_word = True

通过以上介绍，我们可以看到树形结构在计算机科学中的广泛应用和重要性。通过了解树的基本概念和操作，可以更好地理解和实现相关算法。

点击查看更多内容
发表于 2024.09.23 13:01， 共 128 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

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

评论

作者其他优质文章

正在加载中

交互式爱情

手记
篇
粉丝
23
获赞与收藏
76

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消