TreeNode 并不是一个 Python 内置的、像 int 或 str 那样的原生数据类型，它是一个自定义的类，用于在计算机科学中模拟和操作树形数据结构。

树是一种非常重要的非线性数据结构,由节点和边组成，每个节点可以包含数据和指向其子节点的指针。TreeNode 就是构成这棵树的基本“砖块”。

TreeNode 的基本定义

一个最基础的 TreeNode 类通常包含三个部分：

1. 数据域：用于存储节点的值，这可以是任何数据类型，如整数、字符串、对象等。
2. 左子节点指针：指向该节点的左孩子。
3. 右子节点指针：指向该节点的右孩子。（对于二叉树而言）

下面是一个最常见的 TreeNode 类的定义，通常用于表示二叉树的节点：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        """
        初始化一个树节点。
        参数:
            val: 节点存储的值，默认为 0。
            left: 左子节点，默认为 None。
            right: 右子节点，默认为 None。
        """
        self.val = val      # 数据域
        self.left = left    # 左子节点指针
        self.right = right  # 右子节点指针
    # 为了方便调试和打印，可以添加一个 __repr__ 方法
    def __repr__(self):
        return f"TreeNode({self.val})"

解释：

• self.val: 存储节点的值，在一个表示数学表达式的树中，val 可能是 , 5, 等。
• self.left: 指向一个 TreeNode 对象，代表其左子节点，如果没有左子节点，则为 None。
• self.right: 指向一个 TreeNode 对象，代表其右子节点，如果没有右子节点，则为 None。

如何使用 TreeNode

创建 TreeNode 对象就像创建任何类的实例一样。

示例：创建一个简单的二叉树

假设我们要构建下面这棵树：

      1
     / \
    2   3
   / \
  4   5

我们可以这样创建它：

# 1. 创建叶子节点（没有子节点的节点）
node4 = TreeNode(4)
node5 = TreeNode(5)
node3 = TreeNode(3)
# 2. 创建中间层节点，并连接其子节点
node2 = TreeNode(2, left=node4, right=node5)
# 3. 创建根节点，并连接其子节点
root = TreeNode(1, left=node2, right=node3)
# 'root' 变量就代表了这棵树的根节点
# 我们可以通过 root.val, root.left, root.right 来访问它的内容
print(f"根节点的值是: {root.val}")
print(f"根节点的左子节点的值是: {root.left.val}")
print(f"根节点的右子节点的值是: {root.right.val}")
print(f"根节点的左子节点的左子节点的值是: {root.left.left.val}")
# 打印整个树结构（需要自定义一个辅助函数）
def print_tree(node, level=0, prefix="Root: "):
    if node is not None:
        print(" " * (level * 4) + prefix + str(node.val))
        if node.left is not None or node.right is not None:
            print_tree(node.left, level + 1, "L--- ")
            print_tree(node.right, level + 1, "R--- ")
print("\n打印树的结构:")
print_tree(root)

输出：

根节点的值是: 1
根节点的左子节点的值是: 2
根节点的右子节点的值是: 3
根节点的左子节点的左子节点的值是: 4
打印树的结构:
Root: 1
    L--- 2
        L--- 4
        R--- 5
    R--- 3

在算法题中的常见表示

在 LeetCode、HackerRank 等算法平台上，树的输入通常不是以对象的形式直接给出，而是以序列化的方式（如字符串或列表）给出，你需要一个辅助函数将这些序列化数据转换成 TreeNode 对象。

常见序列化格式：层级遍历序列

上面的树 [1, 2, 3, null, 5] 或 "1,2,3,null,5"。

这里的 null 或 None 表示一个空节点。

示例：编写一个将列表转换为 TreeNode 树的函数

def list_to_tree(nums):
    """
    将一个表示层级遍历的列表（包含 None）转换为二叉树的根节点。
    """
    if not nums:
        return None
    # 创建根节点
    root = TreeNode(nums[0])
    # 使用队列来辅助构建树
    queue = [root]
    i = 1
    while queue and i < len(nums):
        current_node = queue.pop(0)
        # 处理左子节点
        if nums[i] is not None:
            current_node.left = TreeNode(nums[i])
            queue.append(current_node.left)
        i += 1
        # 处理右子节点
        if i < len(nums) and nums[i] is not None:
            current_node.right = TreeNode(nums[i])
            queue.append(current_node.right)
        i += 1
    return root
# 使用示例
# 列表 [1, 2, 3, None, 5] 表示的树:
#      1
#     / \
#    2   3
#     \
#      5
input_list = [1, 2, 3, None, 5]
tree_root = list_to_tree(input_list)
print("\n由列表转换的树:")
print_tree(tree_root)

输出：

由列表转换的树:
Root: 1
    L--- 2
        R--- 5
    R--- 3

树的遍历

对树的操作通常从遍历开始,主要有三种深度优先遍历方式：

1. 前序遍历：根 -> 左 -> 右
2. 中序遍历：左 -> 根 -> 右
3. 后序遍历：左 -> 右 -> 根

示例：实现遍历函数

def preorder_traversal(node):
    """前序遍历"""
    if not node:
        return []
    return [node.val] + preorder_traversal(node.left) + preorder_traversal(node.right)
def inorder_traversal(node):
    """中序遍历"""
    if not node:
        return []
    return inorder_traversal(node.left) + [node.val] + inorder_traversal(node.right)
def postorder_traversal(node):
    """后序遍历"""
    if not node:
        return []
    return postorder_traversal(node.left) + postorder_traversal(node.right) + [node.val]
# 使用我们之前创建的 root = TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3))
print("\n遍历我们手动创建的树:")
print("前序遍历:", preorder_traversal(root))  # 输出: [1, 2, 4, 5, 3]
print("中序遍历:", inorder_traversal(root))   # 输出: [4, 2, 5, 1, 3]
print("后序遍历:", postorder_traversal(root)) # 输出: [4, 5, 2, 3, 1]

掌握 TreeNode 的定义和使用是学习树相关算法（如深度优先搜索、广度优先搜索、二叉树的各种操作）的第一步和最基础的一步。