《数据之美》：树结构的精妙世界与算法实践-优快云博客

一、树：层次化数据的完美表示
1.1 树的基本概念与术语
树是一种非线性的分层数据结构，由节点和边组成。与线性数据结构不同，树能够高效地表示层次关系和嵌套结构。

核心术语：

节点：树的基本单位，包含数据和指向子节点的引用
根节点：树的顶端节点，没有父节点
子节点：一个节点的直接后代
父节点：一个节点的直接祖先
叶节点：没有子节点的节点
深度：从根节点到该节点的路径长度
高度：从该节点到最深叶节点的路径长度
度：一个节点拥有的子节点数量

二、二叉树：树结构的基础
2.1 二叉树的基本概念
二叉树是每个节点最多有两个子节点的树结构，分别称为左子节点和右子节点。

// 二叉树节点定义
class TreeNode {
int val;
TreeNode left;
TreeNode right;

TreeNode(int val) {
this.val = val;
this.left = null;
this.right = null;
}
}
2.2 二叉树的遍历算法
递归遍历实现：

public class BinaryTreeTraversal {
// 前序遍历：根 -> 左 -> 右
public void preorder(TreeNode root) {
if (root != null) {
System.out.print(root.val + " ");
preorder(root.left);
preorder(root.right);
}
}

// 中序遍历：左 -> 根 -> 右
public void inorder(TreeNode root) {
if (root != null) {
inorder(root.left);
System.out.print(root.val + " ");
inorder(root.right);
}
}

// 后序遍历：左 -> 右 -> 根
public void postorder(TreeNode root) {
if (root != null) {
postorder(root.left);
postorder(root.right);
System.out.print(root.val + " ");
}
}

// 层次遍历（广度优先）
public void levelOrder(TreeNode root) {
if (root == null) return;

Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);

while (!queue.isEmpty()) {
TreeNode node = queue.poll();
System.out.print(node.val + " ");

if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
}
}
迭代遍历实现：

// 迭代前序遍历
public List<Integer> preorderIterative(TreeNode root) {
List<Integer> result = new ArrayList<>();
if (root == null) return result;

Stack<TreeNode> stack = new Stack<>();
stack.push(root);

while (!stack.isEmpty()) {
TreeNode node = stack.pop();
result.add(node.val);

if (node.right != null) stack.push(node.right);
if (node.left != null) stack.push(node.left);
}

return result;
}

// 迭代中序遍历
public List<Integer> inorderIterative(TreeNode root) {
List<Integer> result = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
TreeNode current = root;

while (current != null || !stack.isEmpty()) {
while (current != null) {
stack.push(current);
current = current.left;
}

current = stack.pop();
result.add(current.val);
current = current.right;
}

return result;
}
三、特殊类型的二叉树
3.1 完全二叉树
完全二叉树是指除了最后一层外，其他各层都是满的，并且最后一层的节点都集中在左侧。

特性：

高度为h的完全二叉树，节点数在[2^h, 2^(h+1)-1]之间
可以用数组高效存储
堆数据结构基于完全二叉树实现

// 判断是否为完全二叉树
public boolean isCompleteTree(TreeNode root) {
if (root == null) return true;

Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
boolean foundNull = false;

while (!queue.isEmpty()) {
TreeNode node = queue.poll();

if (node == null) {
foundNull = true;
} else {
if (foundNull) return false; // 在null节点后出现非null节点
queue.offer(node.left);
queue.offer(node.right);
}
}

return true;
}
3.2 平衡二叉树
平衡二叉树（AVL树）是任何节点的左右子树高度差不超过1的二叉树。

AVL树实现：

class AVLNode {
int val;
int height;
AVLNode left;
AVLNode right;

AVLNode(int val) {
this.val = val;
this.height = 1;
}
}

public class AVLTree {
private int height(AVLNode node) {
return node == null ? 0 : node.height;
}

private int getBalance(AVLNode node) {
return node == null ? 0 : height(node.left) - height(node.right);
}

private AVLNode rightRotate(AVLNode y) {
AVLNode x = y.left;
AVLNode T2 = x.right;

x.right = y;
y.left = T2;

y.height = Math.max(height(y.left), height(y.right)) + 1;
x.height = Math.max(height(x.left), height(x.right)) + 1;

return x;
}

private AVLNode leftRotate(AVLNode x) {
AVLNode y = x.right;
AVLNode T2 = y.left;

y.left = x;
x.right = T2;

x.height = Math.max(height(x.left), height(x.right)) + 1;
y.height = Math.max(height(y.left), height(y.right)) + 1;

return y;
}

public AVLNode insert(AVLNode node, int val) {
if (node == null) return new AVLNode(val);

if (val < node.val) {
node.left = insert(node.left, val);
} else if (val > node.val) {
node.right = insert(node.right, val);
} else {
return node; // 不允许重复值
}

node.height = 1 + Math.max(height(node.left), height(node.right));
int balance = getBalance(node);

// 左左情况
if (balance > 1 && val < node.left.val) {
return rightRotate(node);
}

// 右右情况
if (balance < -1 && val > node.right.val) {
return leftRotate(node);
}

// 左右情况
if (balance > 1 && val > node.left.val) {
node.left = leftRotate(node.left);
return rightRotate(node);
}

// 右左情况
if (balance < -1 && val < node.right.val) {
node.right = rightRotate(node.right);
return leftRotate(node);
}

return node;
}
}
四、高级树结构
4.1 红黑树
红黑树是一种自平衡的二叉搜索树，通过对节点着色和旋转操作来保持平衡。

红黑树特性：

每个节点是红色或黑色
根节点是黑色
所有叶子节点（NIL）是黑色
红色节点的子节点都是黑色
从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点

class RBNode {
int val;
boolean isRed;
RBNode left;
RBNode right;
RBNode parent;

RBNode(int val) {
this.val = val;
this.isRed = true; // 新节点默认为红色
}
}

public class RedBlackTree {
private RBNode root;

private void rotateLeft(RBNode x) {
RBNode y = x.right;
x.right = y.left;

if (y.left != null) {
y.left.parent = x;
}

y.parent = x.parent;

if (x.parent == null) {
root = y;
} else if (x == x.parent.left) {
x.parent.left = y;
} else {
x.parent.right = y;
}

y.left = x;
x.parent = y;
}

private void rotateRight(RBNode x) {
RBNode y = x.left;
x.left = y.right;

if (y.right != null) {
y.right.parent = x;
}

y.parent = x.parent;

if (x.parent == null) {
root = y;
} else if (x == x.parent.right) {
x.parent.right = y;
} else {
x.parent.left = y;
}

y.right = x;
x.parent = y;
}

public void insert(int val) {
RBNode node = new RBNode(val);
// 标准BST插入
// ...（省略BST插入代码）

// 修复红黑树性质
fixInsert(node);
}

private void fixInsert(RBNode node) {
while (node != root && node.parent.isRed) {
if (node.parent == node.parent.parent.left) {
RBNode uncle = node.parent.parent.right;

if (uncle != null && uncle.isRed) {
// 情况1：叔节点是红色
node.parent.isRed = false;
uncle.isRed = false;
node.parent.parent.isRed = true;
node = node.parent.parent;
} else {
if (node == node.parent.right) {
// 情况2：叔节点是黑色，当前节点是右孩子
node = node.parent;
rotateLeft(node);
}
// 情况3：叔节点是黑色，当前节点是左孩子
node.parent.isRed = false;
node.parent.parent.isRed = true;
rotateRight(node.parent.parent);
}
} else {
// 对称情况
// ...（省略对称代码）
}
}

root.isRed = false;
}
}
4.2 B树和B+树
B树和B+树是多路搜索树，特别适合磁盘存储系统。

B树特性：

每个节点最多有m个子节点
除根节点外，每个节点至少有⌈m/2⌉个子节点
所有叶子节点在同一层
B+树与B树的区别：

B+树的所有数据都存储在叶子节点
B+树的叶子节点通过指针相连，支持范围查询
B+树的内部节点只存储键，不存储数据

// B+树节点基本结构
class BPlusNode {
boolean isLeaf;
int[] keys;
BPlusNode[] children;
BPlusNode next; // 用于叶子节点的链表连接
Object[] values; // 仅叶子节点存储值

// 省略具体实现...
}

public class BPlusTree {
private BPlusNode root;
private int order; // 树的阶数

public BPlusTree(int order) {
this.order = order;
this.root = new BPlusNode(true);
}

public void insert(int key, Object value) {
// B+树插入实现
// 1. 查找合适的叶子节点
// 2. 插入键值对
// 3. 如果节点溢出，进行分裂
// 4. 向上递归调整
}

public Object search(int key) {
BPlusNode current = root;

while (!current.isLeaf) {
// 在内部节点中查找合适的子节点
int i = 0;
while (i < current.keys.length && key >= current.keys[i]) {
i++;
}
current = current.children[i];
}

// 在叶子节点中查找键
for (int i = 0; i < current.keys.length; i++) {
if (current.keys[i] == key) {
return current.values[i];
}
}

return null; // 未找到
}

// 范围查询（利用叶子节点的链表连接）
public List<Object> rangeSearch(int startKey, int endKey) {
List<Object> result = new ArrayList<>();
BPlusNode current = findLeaf(startKey);

while (current != null) {
for (int i = 0; i < current.keys.length; i++) {
if (current.keys[i] > endKey) {
return result;
}
if (current.keys[i] >= startKey) {
result.add(current.values[i]);
}
}
current = current.next;
}

return result;
}

private BPlusNode findLeaf(int key) {
BPlusNode current = root;

while (!current.isLeaf) {
int i = 0;
while (i < current.keys.length && key >= current.keys[i]) {
i++;
}
current = current.children[i];
}

return current;
}
}
五、树结构的应用场景
5.1 数据库索引
B+树是数据库索引的标准实现，提供了高效的点查询和范围查询能力。

// 模拟数据库索引使用
public class DatabaseIndexExample {
private BPlusTree index;

public DatabaseIndexExample() {
index = new BPlusTree(100); // 100阶B+树
}

public void addRecord(int id, String data) {
index.insert(id, data);
}

public String getRecord(int id) {
return (String) index.search(id);
}

public List<String> getRecordsInRange(int startId, int endId) {
return index.rangeSearch(startId, endId);
}
}
5.2 文件系统
文件系统通常使用B树或B+树来组织目录结构和文件索引。

// 文件系统节点
class FileSystemNode {
String name;
boolean isDirectory;
List<FileSystemNode> children; // 用于目录
String content; // 用于文件

// 使用树结构组织文件系统
public FileSystemNode find(String path) {
String[] parts = path.split("/");
FileSystemNode current = this;

for (String part : parts) {
if (part.isEmpty()) continue;

boolean found = false;
if (current.isDirectory) {
for (FileSystemNode child : current.children) {
if (child.name.equals(part)) {
current = child;
found = true;
break;
}
}
}

if (!found) return null;
}

return current;
}
}
5.3 表达式树
二叉树可以用于表示数学表达式，其中内部节点是操作符，叶子节点是操作数。

// 表达式树求值
public class ExpressionTree {
static class Node {
String value;
Node left, right;

Node(String value) {
this.value = value;
}
}

public double evaluate(Node root) {
if (root == null) return 0;

if (root.left == null && root.right == null) {
return Double.parseDouble(root.value);
}

double leftVal = evaluate(root.left);
double rightVal = evaluate(root.right);

switch (root.value) {
case "+": return leftVal + rightVal;
case "-": return leftVal - rightVal;
case "*": return leftVal * rightVal;
case "/": return leftVal / rightVal;
default: throw new IllegalArgumentException("Invalid operator: " + root.value);
}
}

// 构建表达式树
public Node buildExpressionTree(String[] postfix) {
Stack<Node> stack = new Stack<>();

for (String token : postfix) {
if (isOperator(token)) {
Node right = stack.pop();
Node left = stack.pop();
Node operatorNode = new Node(token);
operatorNode.left = left;
operatorNode.right = right;
stack.push(operatorNode);
} else {
stack.push(new Node(token));
}
}

return stack.pop();
}

private boolean isOperator(String token) {
return token.equals("+") || token.equals("-") ||
token.equals("*") || token.equals("/");
}
}
5.4 决策树和机器学习
树结构在机器学习中广泛应用于决策树算法。

// 简单的决策树实现
public class DecisionTree {
static class DecisionNode {
String feature;
double threshold;
DecisionNode left; // 满足条件
DecisionNode right; // 不满足条件
String result; // 叶节点的预测结果

boolean isLeaf() {
return left == null && right == null;
}
}

public String predict(DecisionNode root, Map<String, Double> features) {
if (root.isLeaf()) {
return root.result;
}

double value = features.get(root.feature);
if (value <= root.threshold) {
return predict(root.left, features);
} else {
return predict(root.right, features);
}
}
}
六、性能分析与比较
6.1 各种树结构的性能比较
树类型

平均查找时间

平均插入时间

平均删除时间

适用场景

二叉搜索树

O(log n)

内存中的小型数据集

AVL树

O(log n)

需要严格平衡的场景

红黑树

O(log n)

集合类实现（如Java TreeMap）

B树

O(log n)

文件系统、数据库索引

B+树

O(log n)

数据库索引、范围查询

6.2 选择指南
小规模内存数据：使用普通二叉搜索树或平衡二叉树
需要严格平衡：选择AVL树
频繁插入删除：选择红黑树（插入删除性能更好）
磁盘存储系统：选择B树或B+树
范围查询需求：选择B+树（叶子节点链表优化）
七、Java中的树实现
7.1 TreeMap和TreeSet
Java集合框架提供了基于红黑树的实现：

// TreeMap示例
TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(3, "Three");
treeMap.put(1, "One");
treeMap.put(2, "Two");

// 自动按键排序
for (Map.Entry<Integer, String> entry : treeMap.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 输出: 1: One, 2: Two, 3: Three

// 范围查询
SortedMap<Integer, String> subMap = treeMap.subMap(1, 3); // 1 <= key < 3

// TreeSet示例
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(5);
treeSet.add(2);
treeSet.add(8);

// 获取最大值和最小值
int min = treeSet.first(); // 2
int max = treeSet.last(); // 8
7.2 自定义树结构实现

// 通用的二叉树实现
public class GenericBinaryTree<T extends Comparable<T>> {
class Node {
T data;
Node left;
Node right;

Node(T data) {
this.data = data;
}
}

private Node root;

public void insert(T data) {
root = insertRec(root, data);
}

private Node insertRec(Node root, T data) {
if (root == null) {
return new Node(data);
}

if (data.compareTo(root.data) < 0) {
root.left = insertRec(root.left, data);
} else if (data.compareTo(root.data) > 0) {
root.right = insertRec(root.right, data);
}

return root;
}

public boolean contains(T data) {
return containsRec(root, data);
}

private boolean containsRec(Node root, T data) {
if (root == null) return false;

int cmp = data.compareTo(root.data);
if (cmp == 0) return true;
if (cmp < 0) return containsRec(root.left, data);
return containsRec(root.right, data);
}
}
总结
树结构是计算机科学中最重要的数据结构之一，提供了高效的数据组织和管理能力。从简单的二叉树到复杂的B+树，每种树结构都有其特定的应用场景和优势。