树树是一种基于链表的数据结构二叉树（binary tree）是一种非线性数据结构体体现了一分为二的分治逻辑

1. 二叉树

1.1. 基本概念

树是一种基于链表的数据结构
二叉树（binary tree）是一种非线性数据结构
体现了一分为二的分治逻辑
基本单元为节点，包括父节点，子节点，叶节点，其中子节点分为左子结点和右子结点
每个节点包含值、左子节点引用和右子节点引用
左子节点引用和右子节点引用是每个节点的两个指针，分别指向左子节点（left-child node）和右子节点（right-child node），该节点被称为这两个子节点的父节点（parent node）。
左子结点及其以下节点形成的树称为该节点的左子树（left subtree），同理可得右子树（right subtree）。
在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树

class TreeNode:
	"""二叉树节点类"""
	def __init__(self, val: int):
	    self.val: int = val                # 节点值
	    self.left: TreeNode | None = None  # 左子节点引用
	    self.right: TreeNode | None = None # 右子节点引用

/* 二叉树节点结构体 */
struct TreeNode {
    int val;          // 节点值
    TreeNode *left;   // 左子节点指针
    TreeNode *right;  // 右子节点指针
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

1.2. 常用术语

根节点（root node）：位于二叉树顶层的节点，没有父节点。
叶节点（leaf node）：没有子节点的节点，其两个指针均指向 None 。
边（edge）：连接两个节点的线段，即节点引用（指针）。
节点所在的层（level）：从顶至底递增，根节点所在层为 1 。
节点的度（degree）：节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2 。
二叉树的高度（height）：从根节点到最远叶节点所经过的边的数量。
节点的深度（depth）：从根节点到该节点所经过的边（或节点）的数量。
节点的高度（height）：从距离该节点最远的叶节点到该节点所经过的边（或节点）的数量。

1.3. 二叉树基本操作

1.3.1. 初始化二叉树

初始化二叉树和[[#^fbe4de|初始化链表]] 的操作类似，首先初始化节点，然后初始化指针：

# 初始化二叉树
# 初始化节点
n1 = TreeNode(val=1)
n2 = TreeNode(val=2)
n3 = TreeNode(val=3)
n4 = TreeNode(val=4)
n5 = TreeNode(val=5)
# 构建节点之间的引用（指针）
n1.left = n2
n1.right = n3
n2.left = n4
n2.right = n5

/* 初始化二叉树 */
// 初始化节点
TreeNode* n1 = new TreeNode(1);
TreeNode* n2 = new TreeNode(2);
TreeNode* n3 = new TreeNode(3);
TreeNode* n4 = new TreeNode(4);
TreeNode* n5 = new TreeNode(5);
// 构建节点之间的引用（指针）
n1->left = n2;
n1->right = n3;
n2->left = n4;
n2->right = n5;

1.3.2. 插入和删除

与链表类似，在二叉树中[[#^54bb95|插入与删除节点]]可以通过修改指针来实现。

# 插入与删除节点
p = TreeNode(0)
# 在 n1 -> n2 中间插入节点 P
n1.left = p
p.left = n2
# 删除节点 P
n1.left = n2

/* 插入与删除节点 */
TreeNode* P = new TreeNode(0);
// 在 n1 -> n2 中间插入节点 P
n1->left = P;
P->left = n2;
// 删除节点 P
n1->left = n2;

1.4. 二叉树常见类型

1.5. 二叉树的退化

当二叉树的每层节点都被填满时，达到“完美二叉树”；而当所有节点都偏向一侧时，二叉树退化为“链表”。

完美二叉树是理想情况，可以充分发挥二叉树“分治”的优势。
链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 O(n) 。

结构	第 x 层的节点数量	高度为 h 的树的叶节点数量	高度为 h 的树的节点总数	节点总数为 n 的树的高度
完美二叉树	$2^x-1$	$2^h$	$2^{h+1}-1$	$\log_2(n+1)-1$
链表	1	1	n	n - 1

2. 二叉树的遍历

由于树是一种非线性的数据结构，因此在遍历中需要借助搜索算法实现

二叉树常见的遍历方式包括：层序遍历，前序遍历，中序遍历和后序遍历。

2.1. 层序遍历

层序遍历（level-order traversal）从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点。
层序遍历本质上属于广度优先遍历（breadth-first traversal），也称广度优先搜索（breadth-first search, BFS），它体现了一种“一圈一圈向外扩展”的逐层遍历方式。

def level_order(root: TreeNode | None) -> list[int]:
"""层序遍历，广度优先遍历通常是借助队列来实现的，因为二者都符合先入先出的逻辑"""
# 初始化队列，加入根节点
queue: deque[TreeNode] = deque()
queue.append(root)
# 初始化一个列表，用于保存遍历序列
res = []
while queue:
    node: TreeNode = queue.popleft()  # 队列出队
    res.append(node.val)  # 保存节点值
    if node.left is not None:
        queue.append(node.left)  # 左子节点入队
    if node.right is not None:
        queue.append(node.right)  # 右子节点入队
return res

/* 层序遍历 */
vector<int> levelOrder(TreeNode *root) {
    // 初始化队列，加入根节点
    queue<TreeNode *> queue;
    queue.push(root);
    // 初始化一个列表，用于保存遍历序列
    vector<int> vec;
    while (!queue.empty()) {
        TreeNode *node = queue.front();
        queue.pop();              // 队列出队
        vec.push_back(node->val); // 保存节点值
        if (node->left != nullptr)
            queue.push(node->left); // 左子节点入队
        if (node->right != nullptr)
            queue.push(node->right); // 右子节点入队
    }
    return vec;
}

2.2. 前序、中序、后序遍历

前序、中序和后序遍历都属于深度优先遍历（depth-first traversal），也称深度优先搜索（depth-first search, DFS），它体现了一种“先走到尽头，再回溯继续”的遍历方式。

深度优先遍历就像是绕着整棵二叉树的外围“走”一圈，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历。

在进行深度优先遍历时，采用了递归的思想：

“递”表示开启新方法，程序在此过程中访问下一个节点。
“归”表示函数返回，代表当前节点已经访问完毕。

def pre_order(root: TreeNode | None):
    """前序遍历"""
    if root is None:  # 如果 `root` 为 `None`，表示已遍历到树的末端，函数返回。
        return
    # 访问优先级：根节点 -> 左子树 -> 右子树
    res.append(root.val) #将根节点的值保存到目标列表中
    pre_order(root=root.left) # 递归左子树
    pre_order(root=root.right) # 递归右子树

def in_order(root: TreeNode | None):
    """中序遍历"""
    if root is None:
        return
    # 访问优先级：左子树 -> 根节点 -> 右子树
    in_order(root=root.left)
    res.append(root.val)
    in_order(root=root.right)

def post_order(root: TreeNode | None):
    """后序遍历"""
    if root is None:
        return
    # 访问优先级：左子树 -> 右子树 -> 根节点
    post_order(root=root.left)
    post_order(root=root.right)
    res.append(root.val)

2.3. 复杂度分析

方法	算法	时间复杂度	空间复杂度
层序遍历	广度优先遍历	O(n)：所有节点被访问一次，其中 n 为节点数量。	O(n)：队列中最多同时存在 (n+1)/2 个节点（退化为链表）
前中后遍历	深度优先遍历	O(n)：所有节点被访问一次，其中 n 为节点数量。	O(n)：队列中最多同时存在 n 个节点，（退化为链表）

3. 二叉树的数组表示

二叉树除了可以用链表进行表示外，还可以使用数组进行表示：

3.1. 完美二叉树的表示

3.2. 任意二叉树的表示

当有的节点的子树或叶节点为空时，也就是 none 时，由于层序遍历的局限性，因此无法采用类似于完美二叉树的表示方法：

为了解决此问题，我们可以考虑在层序遍历序列中显式地写出所有 None：

根据以上可知，当二叉树为完全二叉树，也就是只有在二叉树的叶节点层且靠右的部分为空时，使用数组进行表示最佳，空的节点可以在数组中直接省略：

代码表示二叉树：

给定某节点，获取它的值、左（右）子节点、父节点。
获取前序遍历、中序遍历、后序遍历、层序遍历序列。

class ArrayBinaryTree:
"""数组表示下的二叉树类"""
	
	def __init__(self, arr: list[int | None]):
	    """构造方法"""
	    self._tree = list(arr)
	
	def size(self):
	    """列表容量"""
	    return len(self._tree)
	
	def val(self, i: int) -> int | None:
	    """获取索引为 i 节点的值"""
	    # 若索引越界，则返回 None ，代表空位
	    if i < 0 or i >= self.size():
	        return None
	    return self._tree[i]
	
	def left(self, i: int) -> int | None:
	    """获取索引为 i 节点的左子节点的索引"""
	    return 2 * i + 1
	    """
	def left(self, i):
		 """
		 获取索引为 i 节点的左子节点的索引
		 
		 Args:
		     i (int): 节点的索引
		 
		 Returns:
		     int | None: 左子节点的索引，如果没有左子节点则返回 None
		 """
		 if 2 * i + 1 < len(self):
		     return 2 * i + 1
		 else:
		     return None
"""
	
	def right(self, i: int) -> int | None:
	    """获取索引为 i 节点的右子节点的索引"""
	    return 2 * i + 2
	
	def parent(self, i: int) -> int | None:
	    """获取索引为 i 节点的父节点的索引"""
	    return (i - 1) // 2
	
	def level_order(self) -> list[int]:
	    """层序遍历"""
	    self.res = []
	    # 直接遍历数组
	    for i in range(self.size()):
	        if self.val(i) is not None:
	            self.res.append(self.val(i))
	    return self.res
	
	def dfs(self, i: int, order: str):
	    """深度优先遍历"""
	    if self.val(i) is None:
	        return
	    # 前序遍历
	    if order == "pre":
	        self.res.append(self.val(i))
	    self.dfs(self.left(i), order)
	    # 中序遍历
	    if order == "in":
	        self.res.append(self.val(i))
	    self.dfs(self.right(i), order)
	    # 后序遍历
	    if order == "post":
	        self.res.append(self.val(i))
	
	def pre_order(self) -> list[int]:
	    """前序遍历"""
	    self.res = []
	    self.dfs(0, order="pre")
	    return self.res
	
	def in_order(self) -> list[int]:
	    """中序遍历"""
	    self.res = []
	    self.dfs(0, order="in")
	    return self.res
	
	def post_order(self) -> list[int]:
	    """后序遍历"""
	    self.res = []
	    self.dfs(0, order="post")
	    return self.res

/* 数组表示下的二叉树类 */
class ArrayBinaryTree {
  public:
    /* 构造方法 */
    ArrayBinaryTree(vector<int> arr) {
        tree = arr;
    }

    /* 列表容量 */
    int size() {
        return tree.size();
    }

    /* 获取索引为 i 节点的值 */
    int val(int i) {
        // 若索引越界，则返回 INT_MAX ，代表空位
        if (i < 0 || i >= size())
            return INT_MAX;
        return tree[i];
    }

    /* 获取索引为 i 节点的左子节点的索引 */
    int left(int i) {
        return 2 * i + 1;
    }

    /* 获取索引为 i 节点的右子节点的索引 */
    int right(int i) {
        return 2 * i + 2;
    }

    /* 获取索引为 i 节点的父节点的索引 */
    int parent(int i) {
        return (i - 1) / 2;
    }

    /* 层序遍历 */
    vector<int> levelOrder() {
        vector<int> res;
        // 直接遍历数组
        for (int i = 0; i < size(); i++) {
            if (val(i) != INT_MAX)
                res.push_back(val(i));
        }
        return res;
    }

    /* 前序遍历 */
    vector<int> preOrder() {
        vector<int> res;
        dfs(0, "pre", res);
        return res;
    }

    /* 中序遍历 */
    vector<int> inOrder() {
        vector<int> res;
        dfs(0, "in", res);
        return res;
    }

    /* 后序遍历 */
    vector<int> postOrder() {
        vector<int> res;
        dfs(0, "post", res);
        return res;
    }

  private:
    vector<int> tree;

    /* 深度优先遍历 */
    void dfs(int i, string order, vector<int> &res) {
        // 若为空位，则返回
        if (val(i) == INT_MAX)
            return;
        // 前序遍历
        if (order == "pre")
            res.push_back(val(i));
        dfs(left(i), order, res);
        // 中序遍历
        if (order == "in")
            res.push_back(val(i));
        dfs(right(i), order, res);
        // 后序遍历
        if (order == "post")
            res.push_back(val(i));
    }
};

这里需要注意到递归结构，需要多次跳出递归函数的，以前序遍历为例

3.3. 优点与局限性

二叉树的数组表示主要有以下优点。

数组存储在连续的内存空间中，对缓存友好，访问与遍历速度较快。
不需要存储指针，比较节省空间。
允许随机访问节点。

然而，数组表示也存在一些局限性。

数组存储需要连续内存空间，因此不适合存储数据量过大的树。
增删节点需要通过数组插入与删除操作实现，效率较低，O(n)。
当二叉树中存在大量 None 时，数组中包含的节点数据比重较低，空间利用率较低。

4. 二叉搜索树

性质：

对于根节点，左子树中所有节点的值 < 根节点的值 < 右子树中所有节点的值。
任意节点的左、右子树也是二叉搜索树，即同样满足条件 1. 。

4.1. 操作：

将二叉搜索树封装为一个类 BinarySearchTree ，并声明一个成员变量 root ，指向树的根节点。

4.1.1. 查找节点

给定目标节点值 num ，可以根据二叉搜索树的性质来查找。如图所示，我们声明一个节点 cur ，指向当前节点，从二叉树的根节点 root 出发，循环比较节点值 cur.val 和 num 之间的大小关系。

二叉搜索树的查找操作与二分查找算法的工作原理一致，都是每轮排除一半情况。循环次数最多为二叉树的高度，当二叉树平衡时，使用 O(log⁡n) 时间。

def search(self, num: int) -> TreeNode | None:
	"""查找节点"""
	cur = self._root
	# 循环查找，越过叶节点后跳出
	while cur is not None:
	    # 目标节点在 cur 的右子树中
	    if cur.val < num:
	        cur = cur.right
	    # 目标节点在 cur 的左子树中
	    elif cur.val > num:
	        cur = cur.left
	    # 找到目标节点，跳出循环
	    else:
	        break
	return cur

/* 查找节点 */
TreeNode *search(int num) {
    TreeNode *cur = root;
    // 循环查找，越过叶节点后跳出
    while (cur != nullptr) {
        // 目标节点在 cur 的右子树中
        if (cur->val < num)
            cur = cur->right;
        // 目标节点在 cur 的左子树中
        else if (cur->val > num)
            cur = cur->left;
        // 找到目标节点，跳出循环
        else
            break;
    }
    // 返回目标节点
    return cur;
}

4.1.2. 插入节点：

二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回。
为了实现插入节点，我们需要借助节点 pre 保存上一轮循环的节点。这样在遍历至 None 时，我们可以获取到其父节点，从而完成节点插入操作。
使用 O(log⁡n) 时间

def insert(self, num: int):
	"""插入节点"""
	# 若树为空，则初始化根节点
	if self._root is None:
	    self._root = TreeNode(num)
	    return
	# 循环查找，越过叶节点后跳出
	cur, pre = self._root, None
	while cur is not None:
	    # 找到重复节点，直接返回
	    if cur.val == num:
	        return
	    pre = cur
	    # 插入位置在 cur 的右子树中
	    if cur.val < num:
	        cur = cur.right
	    # 插入位置在 cur 的左子树中
	    else:
	        cur = cur.left
	# 插入节点
	node = TreeNode(num)
	if pre.val < num:
	    pre.right = node
	else:
	    pre.left = node

/* 插入节点 */
void insert(int num) {
    // 若树为空，则初始化根节点
    if (root == nullptr) {
        root = new TreeNode(num);
        return;
    }
    TreeNode *cur = root, *pre = nullptr;
    // 循环查找，越过叶节点后跳出
    while (cur != nullptr) {
        // 找到重复节点，直接返回
        if (cur->val == num)
            return;
        pre = cur;
        // 插入位置在 cur 的右子树中
        if (cur->val < num)
            cur = cur->right;
        // 插入位置在 cur 的左子树中
        else
            cur = cur->left;
    }
    // 插入节点
    TreeNode *node = new TreeNode(num);
    if (pre->val < num)
        pre->right = node;
    else
        pre->left = node;
}

4.1.3. 删除节点

步骤：先找目标节点再删除，即先搜索再删除，搜索和删除时，根据目标节点子节点的数量分为 0，1，2 三种情况，使用 O(log⁡n) 时间当子节点数量为 0 或者 1 的时候可以进行删除操作，不同的是 0 时直接删除，1 时目标节点替换为子节点。

当待删除节点的度为 2 时，我们无法直接删除它，而需要使用一个节点替换该节点。由于要保持二叉搜索树“左子树 < 根节点 < 右子树”的性质，因此这个节点可以是右子树的最小节点（右子树的左子树）或左子树的最大节点（左子树的右子树）。假设我们选择右子树的最小节点（中序遍历的下一个节点），则删除操作流程如图所示。这里根据中序遍历和二叉树可知整体遍历顺序为 3-15 的数字顺序

找到待删除节点在“中序遍历序列”中的下一个节点，记为 tmp ，即 nex。
用 tmp 的值覆盖待删除节点的值，并在树中递归删除节点 tmp 。

def remove(self, num: int):
	"""删除节点"""
	# 若树为空，直接提前返回
	if self._root is None:
	    return
	# 循环查找，越过叶节点后跳出
	cur, pre = self._root, None
	while cur is not None:
	    # 找到待删除节点，跳出循环
	    if cur.val == num:
	        break
	    pre = cur
	    # 待删除节点在 cur 的右子树中
	    if cur.val < num:
	        cur = cur.right
	    # 待删除节点在 cur 的左子树中
	    else:
	        cur = cur.left
	# 若无待删除节点，则直接返回
	if cur is None:
	    return
	
	# 子节点数量 = 0 or 1
	if cur.left is None or cur.right is None:
	    # 当子节点数量 = 0 / 1 时， child = null / 该子节点
	    child = cur.left or cur.right
	    # 删除节点 cur
	    if cur != self._root:
	        if pre.left == cur:
	            pre.left = child
	        else:
	            pre.right = child
	    else:
	        # 若删除节点为根节点，则重新指定根节点
	        self._root = child
	# 子节点数量 = 2
	else:
	    # 获取中序遍历中 cur 的下一个节点
	    tmp: TreeNode = cur.right
	    while tmp.left is not None:
	        tmp = tmp.left
	    # 递归删除节点 tmp
	    self.remove(tmp.val)
	    # 用 tmp 覆盖 cur
	    cur.val = tmp.val

/* 删除节点 */
void remove(int num) {
    // 若树为空，直接提前返回
    if (root == nullptr)
        return;
    TreeNode *cur = root, *pre = nullptr;
    // 循环查找，越过叶节点后跳出
    while (cur != nullptr) {
        // 找到待删除节点，跳出循环
        if (cur->val == num)
            break;
        pre = cur;
        // 待删除节点在 cur 的右子树中
        if (cur->val < num)
            cur = cur->right;
        // 待删除节点在 cur 的左子树中
        else
            cur = cur->left;
    }
    // 若无待删除节点，则直接返回
    if (cur == nullptr)
        return;
    // 子节点数量 = 0 or 1
    if (cur->left == nullptr || cur->right == nullptr) {
        // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
        TreeNode *child = cur->left != nullptr ? cur->left : cur->right;
        // 删除节点 cur
        if (cur != root) {
            if (pre->left == cur)
                pre->left = child;
            else
                pre->right = child;
        } else {
            // 若删除节点为根节点，则重新指定根节点
            root = child;
        }
        // 释放内存
        delete cur;
    }
    // 子节点数量 = 2
    else {
        // 获取中序遍历中 cur 的下一个节点
        TreeNode *tmp = cur->right;
        while (tmp->left != nullptr) {
            tmp = tmp->left;
        }
        int tmpVal = tmp->val;
        // 递归删除节点 tmp
        remove(tmp->val);
        // 用 tmp 覆盖 cur
        cur->val = tmpVal;
    }
}

4.2. 二叉搜索树的效率

二叉搜索树的各项操作的时间复杂度都是对数阶，具有稳定且高效的性能。只有在高频添加、低频查找删除数据的场景下，数组比二叉搜索树的效率更高。

	无序数组	二叉搜索树
查找	O(n)	O(log⁡n)
插入	O(1)	O(log⁡n)
删除	O(n)	O(log⁡n)
如果在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为链表

datawhalechina.github.io/leetcode-no…

5. AVL 树：

在插入和删除节点时，二叉树搜索树有可能退化为链表导致查找操作的时间复杂度随之劣化，在需要频繁进行增删查改操作的场景中，AVL 树能始终保持高效的数据操作性能，具有很好的应用价值。

5.1. 常见术语

AVL 是一种平衡二叉搜索树，在构建树的时候需要获取节点高度（该节点到它的最远叶节点的距离，叶节点的高度为 0 ，空节点的高度为 −1）和节点平衡因子（节点左子树的高度减去右子树的高度，同时规定空节点的平衡因子为 0）。此时构建的 AVL 为：

class TreeNode:
"""AVL 树节点类"""
	def __init__(self, val: int):
	    self.val: int = val                 # 节点值
	    self.height: int = 0                # 节点高度
	    self.left: TreeNode | None = None   # 左子节点引用
	    self.right: TreeNode | None = None  # 右子节点引用

节点高度的获取：

def height(self, node: TreeNode | None) -> int:
    """获取节点高度"""
    # 空节点高度为 -1 ，叶节点高度为 0
    if node is not None:
        return node.height
    return -1

def update_height(self, node: TreeNode | None):
    """更新节点高度"""
    # 节点高度等于最高子树高度 + 1
    node.height = max([self.height(node.left), self.height(node.right)]) + 1

节点平衡因子的获取：

def balance_factor(self, node: TreeNode | None) -> int:
	"""获取平衡因子"""
	# 空节点平衡因子为 0
	if node is None:
	    return 0
	# 节点平衡因子 = 左子树高度 - 右子树高度
	return self.height(node.left) - self.height(node.right)

5.2. AVL 树旋转

AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中序遍历序列的前提下，使失衡节点重新恢复平衡。这也是旋转的核心操作。

将平衡因子绝对值 >1 的节点称为“失衡节点”。根据节点失衡情况的不同，旋转操作分为四种：右旋、左旋、先右旋后左旋、先左旋后右旋。

右旋和左旋操作在逻辑上是镜像对称的，它们分别解决的两种失衡情况也是对称的。当单独的右旋或单独的左旋无法解决问题时，采用先 xx 后 xx 的旋转方式

5.2.1. 右旋

“向右旋转”是一种形象化的说法，实际上需要通过修改节点指针来实现，

def right_rotate(self, node: TreeNode | None) -> TreeNode | None:
	"""右旋操作"""
	child = node.left
	grand_child = child.right
	# 以 child 为原点，将 node 向右旋转
	child.right = node
	node.left = grand_child
	# 更新节点高度
	self.update_height(node)
	self.update_height(child)
	# 返回旋转后子树的根节点
	return child

5.2.2. 左旋

大致同右旋

def left_rotate(self, node: TreeNode | None) -> TreeNode | None:
	"""左旋操作"""
	child = node.right
	grand_child = child.left
	# 以 child 为原点，将 node 向左旋转
	child.left = node
	node.right = grand_child
	# 更新节点高度
	self.update_height(node)
	self.update_height(child)
	# 返回旋转后子树的根节点
	return child

5.2.3. 先左旋后右旋

5.2.4. 先右旋后左旋

5.2.5. 旋转的选择

失衡节点的平衡因子	子节点的平衡因子	应采用的旋转方法
>1 （左偏树）	>=0	右旋
>1 （左偏树）	>0	先左旋后右旋
<−1 （右偏树）	<=0	左旋
<−1 （右偏树）	<0	先右旋后左旋

def rotate(self, node: TreeNode | None) -> TreeNode | None:
	"""执行旋转操作，使该子树重新恢复平衡"""
	# 获取节点 node 的平衡因子
	balance_factor = self.balance_factor(node)
	# 左偏树
	if balance_factor > 1:
	    if self.balance_factor(node.left) >= 0:
	        # 右旋
	        return self.right_rotate(node)
	    else:
	        # 先左旋后右旋
	        node.left = self.left_rotate(node.left)
	        return self.right_rotate(node)
	# 右偏树
	elif balance_factor < -1:
	    if self.balance_factor(node.right) <= 0:
	        # 左旋
	        return self.left_rotate(node)
	    else:
	        # 先右旋后左旋
	        node.right = self.right_rotate(node.right)
	        return self.left_rotate(node)
	# 平衡树，无须旋转，直接返回
	return node

5.3. AVL 树操作

5.3.1. 插入节点

整体从操作和普通二叉树相同，但是需要保证平衡，需要自下而上使失衡节点恢复平衡

def insert(self, val):
    """插入节点"""
    self._root = self.insert_helper(self._root, val)

def insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
    """递归插入节点（辅助方法）"""
    if node is None:
        return TreeNode(val)
    # 1. 查找插入位置并插入节点
    if val < node.val:
        node.left = self.insert_helper(node.left, val)
    elif val > node.val:
        node.right = self.insert_helper(node.right, val)
    else:
        # 重复节点不插入，直接返回
        return node
    # 更新节点高度
    self.update_height(node)
    # 2. 执行旋转操作，使该子树重新恢复平衡
    return self.rotate(node)

5.3.2. 删除节点

在二叉搜索树的删除节点方法的基础上，需要从底至顶执行旋转操作，使所有失衡节点恢复平衡。

def remove(self, val: int):
    """删除节点"""
    self._root = self.remove_helper(self._root, val)

def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
    """递归删除节点（辅助方法）"""
    if node is None:
        return None
    # 1. 查找节点并删除
    if val < node.val:
        node.left = self.remove_helper(node.left, val)
    elif val > node.val:
        node.right = self.remove_helper(node.right, val)
    else:
        if node.left is None or node.right is None:
            child = node.left or node.right
            # 子节点数量 = 0 ，直接删除 node 并返回
            if child is None:
                return None
            # 子节点数量 = 1 ，直接删除 node
            else:
                node = child
        else:
            # 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
            temp = node.right
            while temp.left is not None:
                temp = temp.left
            node.right = self.remove_helper(node.right, temp.val)
            node.val = temp.val
    # 更新节点高度
    self.update_height(node)
    # 2. 执行旋转操作，使该子树重新恢复平衡
    return self.rotate(node)

5.3.3. 查找节点

与二叉树[[#4.1.1. 查找节点|查找节点]] 的操作相同

5.4. AVL 树典型应用

组织和存储大型数据，适用于高频查找、低频增删的场景。
用于构建数据库中的索引系统。
红黑树也是一种常见的平衡二叉搜索树。相较于 AVL 树，红黑树的平衡条件更宽松，插入与删除节点所需的旋转操作更少，节点增删操作的平均效率更高

5.4.1. 补充知识红黑树：

红黑树是一种自平衡的二叉树数据结构，通过在节点上记录颜色信息（通常用红色和黑色表示）来维持树的高度平衡。其主要目标是减少查找操作的时间复杂度，确保树的高度不会过高，从而提高整体性能。

5.4.1.1. 红黑树的主要特点：

颜色标记：每个节点都有颜色标记，要么红色，要么黑色。
- 红色节点的左子节点必须是黑色。
- 黑色节点的左、右子节点可以是任意颜色。
插入操作：在插入新节点时，通过颜色标记和旋转操作（如左旋转、右旋转、双旋转）调整树的高度，确保树的高度平衡。
删除操作：在删除节点时，通过后插入法（也称为旋转补偿）调整树的高度，保持平衡。
旋转操作：包括左旋转、右旋转和双旋转，用于调整子树的高度和结构。

5.4.1.2. 红黑树的优势：

时间复杂度：查找操作的时间复杂度为O(log n)，插入和删除操作的时间复杂度为O(log n)。
空间复杂度：额外的空间复杂度为O(1)，因为每个节点只需存储颜色信息和子节点指针。

5.4.1.3. 红黑树的实现步骤：

插入节点：
- 插入新节点到目标位置。
- 调整父节点的高度和颜色标记。
- 如果父节点的高度超过平衡因子（通常为2），进行旋转操作。
删除节点：
- 删除目标节点。
- 调整父节点的高度和颜色标记。
- 如果父节点的高度超过平衡因子，通过旋转操作恢复平衡。

5.4.1.4. 旋转操作：

左旋转：将右子节点变为左子节点，右子节点变为左子节点的右子节点。
右旋转：将左子节点变为右子节点，左子节点变为右子节点的左子节点。
双旋转：先进行一次左旋转，再进行一次右旋转，用于恢复高度平衡。

5.4.1.5. 红黑树的平衡因子：

平衡因子通常为2，用于判断是否需要旋转操作。如果一个节点的高度超过平衡因子，说明子树高度不平衡，需要进行旋转操作。

5.4.1.6. 红黑树的应用：

红黑树广泛应用于键值存储、数据库查询、操作系统文件系统等领域，尤其是在需要频繁插入、删除和查找操作的

6. 小结

[[#1.1. 基本概念|二叉树]] 是一种非线性数据结构，体现“一分为二”的分治逻辑。每个二叉树节点包含一个值以及两个指针，分别指向其左子节点和右子节点。
对于二叉树中的某个节点，其左（右）子节点及其以下形成的树被称为该节点的左（右）子树。
二叉树的[[#1.2. 常用术语|相关术语]]包括根节点、叶节点、层、度、边、高度和深度等。
二叉树的初始化、节点插入和节点删除操作等[[#1.3. 二叉树基本操作|基本操作]] 与链表类似。
常见的[[#1.4. 二叉树常见类型|二叉树类型]] 有完美二叉树、完全二叉树、完满二叉树和平衡二叉树。完美二叉树是最理想的状态，而链表是退化后的最差状态。
二叉树可以用数组表示，方法是将节点值和空位按层序遍历顺序排列，并根据父节点与子节点之间的索引映射关系来实现指针。
二叉树的[[#2.1. 层序遍历|层序遍历]] 是一种广度优先搜索方法，它体现了“一圈一圈向外扩展”的逐层遍历方式，通常通过队列来实现。
前序、中序、后序遍历皆属于[[#2.2. 前序、中序、后序遍历|深度优先搜索方法]]，它们体现了“先走到尽头，再回溯继续”的遍历方式，通常使用递归来实现。
[[#4. 二叉搜索树|二叉搜索树]] 是一种高效的元素查找数据结构，其[[#4.1. 操作：|查找、插入和删除操作]]的时间复杂度均为 O(log⁡n) 。当二叉搜索树退化为链表时，各项时间复杂度会劣化至 O(n) 。
AVL 树，也称平衡二叉搜索树，它通过[[#5.2. AVL 树旋转|旋转操作]] 确保在不断插入和删除节点后树仍然保持平衡。
AVL 树的旋转操作包括右旋、左旋、先右旋再左旋、先左旋再右旋。在插入或删除节点后，AVL 树会从底向顶执行旋转操作，使树重新恢复平衡。
对于只有一个节点的二叉树，树的高度和根节点的深度都是 0
二叉搜索树中删除节点操作要分三种情况处理，其中每种情况都需要进行多个步骤的节点操作。
与顺序和逆序遍历数组类似，前序、中序、后序遍历是三种二叉树遍历方法，我们可以使用它们得到一个特定顺序的遍历结果。例如在二叉搜索树中，由于节点大小满足 左子节点值 < 根节点值 < 右子节点值 ，因此我们只要按照“左 → 根 → 右”的优先级遍历树，就可以获得有序的节点序列。
右旋操作 right_rotate(root) 传入的是子树的根节点，最终 return child 返回旋转之后的子树的根节点。子树的根节点和其父节点的连接是在该函数返回后完成的，不属于右旋操作的维护范围。其实返回后添加指针即可完成该操作。
构建树的方法已在二叉搜索树代码中的 build_tree() 方法中给出。至于根节点的选择，我们通常会将输入数据排序，然后将中点元素作为根节点，再递归地构建左右子树。这样做可以最大程度保证树的平衡性。
广度优先遍历到最底层之前，队列中的节点数量是 2h ，是的，例如高度 h=2 的满二叉树，其节点总数 n=7 ，则底层节点数量 4=2h=(n+1)/2 。

树