一文搞懂二叉树

二叉树是计算机科学中最基础的树形数据结构，也是面试、算法开发、工程应用（如表达式解析、搜索索引）的核心考点。本文从概念→分类→存储→遍历→操作→应用层层递进，结合 C++ 代码示例，让你彻底吃透二叉树。

一、二叉树的核心定义与术语

1. 什么是二叉树？

二叉树是n(n≥0)个节点的有限集合，满足：

空树（n=0）；
非空树：有且仅有一个根节点，其余节点分为两个互不相交的子集，分别称为左子树和右子树，且左、右子树也都是二叉树。

核心约束：每个节点的子节点数量不超过2（左孩子、右孩子，顺序不能颠倒）。

2. 必备术语（看图理解更快）

假设一棵简单二叉树结构：

1 （根节点） / \ 2 3 （2是1的左孩子，3是1的右孩子；2和3互为兄弟节点） / 4 （4是2的左孩子，4是叶子节点）

术语	定义
根节点	树的最顶层节点，没有父节点（如节点1）
叶子节点	没有左、右子节点的节点（如节点3、4）
节点的度	节点拥有的子节点数（叶子节点度为0，节点1度为2，节点2度为1）
树的深度/高度	从根节点到最远叶子节点的边数（上图深度为2，根节点深度为0）
层	根节点在第0层，其子节点在第1层，以此类推（上图节点4在第2层）
左/右子树	以节点左/右孩子为根的子树（节点1的左子树是{2,4}，右子树是{3}）

二、二叉树的常见分类（重点区分）

根据节点的排列规则，二叉树分为普通二叉树和特殊二叉树，特殊二叉树在工程中更常用。

1. 满二叉树

定义：除了叶子节点，每个节点的度都为2（所有非叶子节点都有左、右两个孩子），且所有叶子节点都在同一层。
特点：节点数公式2^(h+1) - 1（h为树的深度），结构对称。

2. 完全二叉树

定义：按层序遍历顺序给节点编号，每个节点的编号都与对应的满二叉树节点编号一致（最后一层的叶子节点靠左排列）。
特点：
- 满二叉树是特殊的完全二叉树；
- 适合用数组存储（无需额外存储指针，节省内存）；
- 父节点与子节点的索引关系：若父节点索引为i，左孩子为2i+1，右孩子为2i+2。

3. 二叉搜索树（BST，Binary Search Tree）

工程中最常用的二叉树，核心是有序性

定义：左子树的所有节点值< 根节点值 < 右子树的所有节点值，且左、右子树也都是二叉搜索树。
核心特性：中序遍历结果是严格递增的有序序列。
优势：查找、插入、删除的平均时间复杂度为O(logn)（类似二分查找）。

4. 平衡二叉树

定义：任意节点的左、右子树的高度差的绝对值 ≤ 1（避免二叉搜索树退化成链表）。
常见类型：AVL树（严格平衡）、红黑树（近似平衡，工程中更常用，如 C++map/set的底层实现）。
优势：保证查找、插入、删除的最坏时间复杂度为O(logn)。

三、二叉树的存储结构（C++ 实现）

二叉树有两种存储方式，分别适用于不同场景。

1. 链式存储（最常用，灵活）

用指针连接节点，每个节点包含值、左孩子指针、右孩子指针。

#include <iostream> #include <vector> #include <queue> #include <memory> // 智能指针，避免内存泄漏 using namespace std; // 二叉树节点结构体（C++ 推荐用智能指针管理内存） struct TreeNode { int val; unique_ptr<TreeNode> left; // 左孩子智能指针 unique_ptr<TreeNode> right; // 右孩子智能指针 // 构造函数 TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} };

优势：支持动态插入/删除节点，适合不规则二叉树；

劣势：需要额外存储指针，内存开销略高。

2. 顺序存储（数组存储，适合完全二叉树）

用数组存储节点，利用完全二叉树的索引关系定位父/子节点。

根节点存在arr[0]；
节点arr[i]的左孩子：arr[2i+1]，右孩子：arr[2i+2]；
节点arr[i]的父节点：arr[(i-1)/2]（整数除法）。

示例：完全二叉树[1,2,3,4]的数组存储：

数组索引	0	1	2	3
节点值	1	2	3	4
优势：无需指针，内存利用率高；

劣势：非完全二叉树会浪费大量空间，不支持灵活插入/删除。

四、二叉树的核心操作：遍历（必须掌握）

遍历是指按一定顺序访问二叉树的所有节点，且每个节点仅访问一次。

二叉树的遍历分为深度优先遍历（DFS）和广度优先遍历（BFS）两大类，其中 DFS 又分为 3 种顺序。

1. 深度优先遍历（DFS）：递归+迭代实现

核心思想：先深后广，优先遍历子树，再遍历兄弟节点。

（1）前序遍历（根 → 左 → 右）

访问顺序：先访问根节点 → 递归遍历左子树 → 递归遍历右子树。

递归实现（最简单）：

void preOrder(TreeNode* root) { if (root == nullptr) return; cout << root->val << " "; // 1. 访问根节点 preOrder(root->left.get()); // 2. 遍历左子树 preOrder(root->right.get()); // 3. 遍历右子树 }

迭代实现（用栈模拟递归，工程常用）：

void preOrderIter(TreeNode* root) { if (root == nullptr) return; stack<TreeNode*> st; st.push(root); while (!st.empty()) { TreeNode* node = st.top(); st.pop(); cout << node->val << " "; // 访问根节点 // 栈是“先进后出”，先压右孩子，再压左孩子 if (node->right) st.push(node->right.get()); if (node->left) st.push(node->left.get()); } }

（2）中序遍历（左 → 根 → 右）

访问顺序：递归遍历左子树 → 访问根节点 → 递归遍历右子树。

核心特性：二叉搜索树的中序遍历结果是递增有序序列。

递归实现：

void inOrder(TreeNode* root) { if (root == nullptr) return; inOrder(root->left.get()); // 1. 遍历左子树 cout << root->val << " "; // 2. 访问根节点 inOrder(root->right.get()); // 3. 遍历右子树 }

迭代实现（栈+指针，关键是“左链入栈”）：

void inOrderIter(TreeNode* root) { if (root == nullptr) return; stack<TreeNode*> st; TreeNode* cur = root; while (cur != nullptr || !st.empty()) { // 左链全部入栈 while (cur != nullptr) { st.push(cur); cur = cur->left.get(); } cur = st.top(); st.pop(); cout << cur->val << " "; // 访问根节点 cur = cur->right.get(); // 遍历右子树 } }

（3）后序遍历（左 → 右 → 根）

访问顺序：递归遍历左子树 → 递归遍历右子树 → 访问根节点。

递归实现：

void postOrder(TreeNode* root) { if (root == nullptr) return; postOrder(root->left.get()); // 1. 遍历左子树 postOrder(root->right.get()); // 2. 遍历右子树 cout << root->val << " "; // 3. 访问根节点 }

迭代实现（标记法：区分节点是否已访问）：

void postOrderIter(TreeNode* root) { if (root == nullptr) return; stack<pair<TreeNode*, bool>> st; // <节点, 是否已访问> st.push({root, false}); while (!st.empty()) { auto [node, visited] = st.top(); st.pop(); if (visited) { cout << node->val << " "; // 已访问子树，访问根节点 } else { st.push({node, true}); // 标记为待访问 // 栈先进后出：根 → 右 → 左 if (node->right) st.push({node->right.get(), false}); if (node->left) st.push({node->left.get(), false}); } } }

2. 广度优先遍历（BFS）：层序遍历

核心思想：按层访问，从上到下、从左到右遍历每一层的节点。

实现工具：队列（先进先出）

代码实现：

void levelOrder(TreeNode* root) { if (root == nullptr) return; queue<TreeNode*> q; q.push(root); while (!q.empty()) { int levelSize = q.size(); // 当前层的节点数 // 遍历当前层的所有节点 for (int i = 0; i < levelSize; i++) { TreeNode* node = q.front(); q.pop(); cout << node->val << " "; // 下一层节点入队 if (node->left) q.push(node->left.get()); if (node->right) q.push(node->right.get()); } cout << endl; // 每层换行 } }

遍历结果示例

对如下二叉树：

1 / \ 2 3 / 4

前序遍历：1 2 4 3
中序遍历：4 2 1 3
后序遍历：4 2 3 1
层序遍历：1 → 2 3 → 4

五、二叉搜索树（BST）的常见操作（插入/删除/查找）

二叉搜索树的有序性决定了其操作的规律，以下是核心操作的 C++ 实现。

1. 查找节点

核心逻辑：类似二分查找，根据节点值与根节点的大小关系，递归/迭代查找左/右子树。

// 查找值为target的节点，返回节点指针 TreeNode* searchBST(TreeNode* root, int target) { if (root == nullptr || root->val == target) { return root; } // 小值查左，大值查右 return target < root->val ? searchBST(root->left.get(), target) : searchBST(root->right.get(), target); }

2. 插入节点

核心逻辑：

空树：直接新建节点作为根；
非空树：根据值的大小，找到左/右子树的空位置插入（不破坏有序性）。

// 插入值为val的节点，返回新树的根 unique_ptr<TreeNode> insertBST(unique_ptr<TreeNode> root, int val) { if (root == nullptr) { return make_unique<TreeNode>(val); // 空位置插入新节点 } if (val < root->val) { root->left = insertBST(move(root->left), val); // 插入左子树 } else if (val > root->val) { root->right = insertBST(move(root->right), val); // 插入右子树 } // 已存在该值，直接返回（避免重复） return root; }

3. 删除节点（最复杂，分3种情况）

核心逻辑：找到目标节点后，根据节点的子节点数量分情况处理：

情况1：目标节点是叶子节点 → 直接删除；
情况2：目标节点只有一个子节点 → 用子节点替换目标节点；
情况3：目标节点有两个子节点 → 用右子树的最小节点（或左子树的最大节点）替换目标节点，再删除该最小节点。

// 找到右子树的最小节点（中序后继） TreeNode* findMin(TreeNode* root) { while (root->left != nullptr) { root = root->left.get(); } return root; } // 删除值为val的节点，返回新树的根 unique_ptr<TreeNode> deleteBST(unique_ptr<TreeNode> root, int val) { if (root == nullptr) return root; // 1. 找到目标节点 if (val < root->val) { root->left = deleteBST(move(root->left), val); } else if (val > root->val) { root->right = deleteBST(move(root->right), val); } else { // 2. 找到目标节点，分情况处理 // 情况1+2：无左孩子 或 无右孩子 if (root->left == nullptr) { return move(root->right); // 右孩子替换 } else if (root->right == nullptr) { return move(root->left); // 左孩子替换 } // 情况3：有两个孩子，找右子树最小节点 TreeNode* minNode = findMin(root->right.get()); root->val = minNode->val; // 替换值 // 删除右子树的最小节点 root->right = deleteBST(move(root->right), minNode->val); } return root; }

六、二叉树的工程应用场景

数据搜索与排序
- 二叉搜索树：支持动态的插入、删除、查找，适合频繁更新的数据集；
- 平衡二叉树（红黑树）：C++std::map/std::set的底层实现，保证O(logn)时间复杂度。
表达式解析
- 表达式树：叶子节点是操作数，非叶子节点是运算符，前序遍历对应前缀表达式，后序遍历对应后缀表达式（逆波兰表达式）。
哈夫曼树
- 用于数据压缩（如 Huffman 编码），智驾场景中可压缩传感器采集的点云/图像数据，减少存储和传输开销。
决策树
- 机器学习中的分类模型，每个非叶子节点是一个特征判断，叶子节点是分类结果，用于目标检测的后处理分类。
路径规划
- 树形结构的遍历思想可用于智驾中的局部路径搜索，如 A* 算法的状态树遍历。