数据结构第5章：树和二叉树完全指南（自整理详细图文笔记）

名人说：莫道桑榆晚，为霞尚满天。——刘禹锡（刘梦得，诗豪）
原创笔记：Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊）
上一篇：《数据结构第4章数组和广义表》

目录

zero：思维导图
一、树的基本概念
1. 什么是树？
2. 树的基本术语
3. 树的存储结构
顺序存储 - 双亲表示法
链式存储 - 孩子兄弟表示法

二、二叉树详解
1. 二叉树的定义与特点
2. 特殊的二叉树类型
满二叉树
完全二叉树
二叉排序树（BST）
平衡二叉树（AVL树）

3. 二叉树的重要性质
4. 二叉树的存储结构
顺序存储
链式存储（最常用）

5. 二叉树的遍历
先序遍历（根-左-右）
中序遍历（左-根-右）
后序遍历（左-右-根）
层序遍历（使用队列）

6. 线索二叉树

三、树、森林与二叉树的转换
1. 树转二叉树
2. 森林转二叉树
3. 遍历关系

四、树和二叉树的应用
1. 哈夫曼树与哈夫曼编码
什么是哈夫曼树？
哈夫曼算法构造步骤
哈夫曼编码

2. 并查集

五、实战编程与常见问题
1. 经典算法实现
求二叉树的高度
统计二叉树结点个数
判断是否为完全二叉树

2. 面试高频题目
题目1：二叉树的镜像
题目2：二叉树的最大路径和
题目3：验证二叉搜索树

3. 性能优化技巧
非递归遍历（避免栈溢出）
层序遍历的变种（按层输出）

4. 实际应用案例
文件系统目录树

总结

zero：思维导图

在这里插入图片描述

一、树的基本概念

1. 什么是树？

想象一下家族族谱或者公司的组织架构图，它们都是典型的树结构。在计算机中，树（Tree）是由结点（Node）和边（Edge）组成的层次型数据结构。

2. 树的基本术语

让我们通过一个直观的例子来理解这些术语：

在这里插入图片描述

根结点：树的顶端，没有父结点的结点（就像族谱中的祖先）
父结点（双亲结点）：上一层的结点
子结点（孩子结点）：下一层的结点
兄弟结点：同一个父结点的子结点
叶子结点：没有子结点的结点（度为0）
分支结点：有子结点的结点（度大于0）
树的高度/深度：从根到叶子的最长路径上的结点数
路径长度：路径上边的个数

3. 树的存储结构

顺序存储 - 双亲表示法

在这里插入图片描述

这种方法用数组存储，每个结点保存数据和父结点的下标：

typedef struct {
    char data;      // 结点数据
    int parent;     // 父结点下标，根结点为-1
} PTNode;

typedef struct {
    PTNode nodes[MAXSIZE];
    int nodeCount;  // 结点数量
} PTree;

链式存储 - 孩子兄弟表示法

在这里插入图片描述

采用"左孩子右兄弟"的策略，每个结点包含：

数据域
指向第一个孩子的指针
指向右兄弟的指针

typedef struct TreeNode {
    char data;
    struct TreeNode* firstChild;  // 第一个孩子
    struct TreeNode* nextSibling; // 右兄弟
} TreeNode;

二、二叉树详解

1. 二叉树的定义与特点

二叉树（Binary Tree）是每个结点最多有两个子结点的树结构，具有以下特点：

每个结点的度不超过2（最多2个孩子）
子树有左右之分，顺序不能颠倒
即使只有一个子结点，也要明确是左孩子还是右孩子

A.b为a的左子树

B.c为a的右子树

2. 特殊的二叉树类型

在这里插入图片描述

满二叉树

高度为h，含有 2^h - 1 个结点的二叉树。特点是每一层都"满员"。

在这里插入图片描述

完全二叉树

除了最后一层，其他层都是满的，且最后一层的结点都靠左排列。

在这里插入图片描述

反例：

在这里插入图片描述

二叉排序树（BST）

满足"左 < 根 < 右"性质的二叉树，支持高效的查找操作。

在这里插入图片描述

平衡二叉树（AVL树）

任意结点的左右子树高度差不超过1的二叉排序树。

在这里插入图片描述

3. 二叉树的重要性质

性质1：叶结点数 = 度为2的结点数 + 1 即： $n_0 = n_2 +1$
性质2：第k层最多有 2^(k-1) 个结点
性质3：高度为h的二叉树最多有 2^h - 1 个结点
性质4：n个结点的完全二叉树高度为 ⌊log₂n⌋ + 1

4. 二叉树的存储结构

顺序存储

使用数组，下标之间有规律：

结点i的左孩子：2i
结点i的右孩子：2i + 1
结点i的父结点：⌊i/2⌋

a.完全二叉树的顺序存储

在这里插入图片描述

b.非完全二叉树（一般二叉树）的顺序存储

在这里插入图片描述
可以看出非完全二叉树会浪费很多存储单元，不适合进行顺序存储

链式存储（最常用）

typedef struct BiTNode {
    char data;                  // 数据域
    struct BiTNode* lchild;     // 左孩子指针
    struct BiTNode* rchild;     // 右孩子指针
} BiTNode, *BiTree;

在这里插入图片描述

5. 二叉树的遍历

二叉树遍历是指按照某种规则访问每个结点有且仅有一次。

在这里插入图片描述

先序遍历（根-左-右）

void PreOrder(BiTree T) {
    if (T) {
        visit(T);           // 访问根结点
        PreOrder(T->lchild); // 遍历左子树
        PreOrder(T->rchild); // 遍历右子树
    }
}

中序遍历（左-根-右）

void InOrder(BiTree T) {
    if (T) {
        InOrder(T->lchild);  // 遍历左子树
        visit(T);            // 访问根结点
        InOrder(T->rchild);  // 遍历右子树
    }
}

后序遍历（左-右-根）

void PostOrder(BiTree T) {
    if (T) {
        PostOrder(T->lchild); // 遍历左子树
        PostOrder(T->rchild); // 遍历右子树
        visit(T);             // 访问根结点
    }
}

层序遍历（使用队列）

void LevelOrder(BiTree T) {
    Queue Q;
    InitQueue(&Q);
    if (T) EnQueue(&Q, T);
    
    while (!IsEmpty(Q)) {
        DeQueue(&Q, &T);
        visit(T);
        if (T->lchild) EnQueue(&Q, T->lchild);
        if (T->rchild) EnQueue(&Q, T->rchild);
    }
}

6. 线索二叉树

线索二叉树是利用空闲指针域存储前驱和后继信息的特殊二叉树。

typedef struct ThreadNode {
    char data;
    struct ThreadNode* lchild, *rchild;
    int ltag, rtag;  // 0表示指向孩子，1表示指向线索
} ThreadNode, *ThreadTree;

优点：可以快速找到前驱和后继结点，提高遍历效率
缺点：插入删除操作变复杂

三、树、森林与二叉树的转换

1. 树转二叉树

口诀：“加线、抹线、旋转”

加线：兄弟结点间连虚线
抹线：只保留每个结点与最左孩子的连线
旋转：虚线向右下方旋转45°

在这里插入图片描述

2. 森林转二叉树

先将森林中每棵树转换为二叉树
将后面的二叉树作为前面二叉树根结点的右子树

在这里插入图片描述

3. 遍历关系

树的先根遍历 ≡ 二叉树的先序遍历
树的后根遍历 ≡ 二叉树的中序遍历
森林的先序遍历 ≡ 二叉树的先序遍历

在这里插入图片描述

四、树和二叉树的应用

1. 哈夫曼树与哈夫曼编码

什么是哈夫曼树？

哈夫曼树是带权路径长度最短的二叉树，广泛应用于数据压缩。

在这里插入图片描述

关键概念：

带权路径长度 = 路径长度 × 结点权值
树的带权路径长度 = 所有叶结点的带权路径长度之和

哈夫曼算法构造步骤

将所有结点放入优先队列（按权值排序）
每次取出两个权值最小的结点
创建新结点作为它们的父结点，权值为两者之和
将新结点放回队列
重复直到只剩一个结点（根结点）

哈夫曼编码

左分支标0，右分支标1（或相反）
从根到叶结点的路径就是该字符的编码
保证前缀编码性质：任何编码都不是其他编码的前缀

在这里插入图片描述

特点：

频率高的字符编码短
频率低的字符编码长
平均编码长度最短

2. 并查集

并查集是处理不相交集合的树型数据结构。

核心操作：

Find(x)：查找x属于哪个集合
Union(x, y)：合并x和y所在的集合

// 查找操作（带路径压缩）
int Find(int x) {
    if (parent[x] != x) {
        parent[x] = Find(parent[x]);  // 路径压缩
    }
    return parent[x];
}

// 合并操作
void Union(int x, int y) {
    int rootX = Find(x);
    int rootY = Find(y);
    if (rootX != rootY) {
        parent[rootX] = rootY;
    }
}

五、实战编程与常见问题

1. 经典算法实现

求二叉树的高度

// 递归求二叉树高度
int TreeHeight(BiTree T) {
    if (T == NULL) return 0;
    
    int leftHeight = TreeHeight(T->lchild);
    int rightHeight = TreeHeight(T->rchild);
    
    return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
}

统计二叉树结点个数

// 递归统计结点数
int CountNodes(BiTree T) {
    if (T == NULL) return 0;
    return CountNodes(T->lchild) + CountNodes(T->rchild) + 1;
}

判断是否为完全二叉树

bool IsComplete(BiTree T) {
    if (T == NULL) return true;
    
    Queue Q;
    InitQueue(&Q);
    EnQueue(&Q, T);
    bool flag = false;  // 标记是否遇到空结点
    
    while (!IsEmpty(Q)) {
        BiTree current;
        DeQueue(&Q, &current);
        
        if (current == NULL) {
            flag = true;
        } else {
            if (flag) return false;  // 遇到空结点后又遇到非空结点
            EnQueue(&Q, current->lchild);
            EnQueue(&Q, current->rchild);
        }
    }
    return true;
}

2. 面试高频题目

题目1：二叉树的镜像

问题：翻转一棵二叉树（每个结点的左右子树交换）

BiTree MirrorTree(BiTree T) {
    if (T == NULL) return NULL;
    
    // 交换左右子树
    BiTree temp = T->lchild;
    T->lchild = T->rchild;
    T->rchild = temp;
    
    // 递归处理子树
    MirrorTree(T->lchild);
    MirrorTree(T->rchild);
    
    return T;
}

题目2：二叉树的最大路径和

问题：给定一个二叉树，找到任意一条路径的最大数字和

int maxSum = INT_MIN;

int MaxPathSumHelper(BiTree T) {
    if (T == NULL) return 0;
    
    // 递归计算左右子树的最大贡献值
    int left = max(0, MaxPathSumHelper(T->lchild));
    int right = max(0, MaxPathSumHelper(T->rchild));
    
    // 当前路径的最大值
    int currentMax = T->data + left + right;
    maxSum = max(maxSum, currentMax);
    
    // 返回以当前结点为根的最大路径和
    return T->data + max(left, right);
}

题目3：验证二叉搜索树

bool IsValidBST(BiTree T, int minVal, int maxVal) {
    if (T == NULL) return true;
    
    if (T->data <= minVal || T->data >= maxVal) {
        return false;
    }
    
    return IsValidBST(T->lchild, minVal, T->data) && 
           IsValidBST(T->rchild, T->data, maxVal);
}

// 调用入口
bool ValidateBST(BiTree T) {
    return IsValidBST(T, INT_MIN, INT_MAX);
}

3. 性能优化技巧

非递归遍历（避免栈溢出）

// 非递归中序遍历
void InOrderNonRecursive(BiTree T) {
    Stack S;
    InitStack(&S);
    BiTree current = T;
    
    while (current != NULL || !IsEmpty(S)) {
        // 一直向左走到底
        while (current != NULL) {
            Push(&S, current);
            current = current->lchild;
        }
        
        // 弹出并访问结点
        Pop(&S, &current);
        visit(current);
        
        // 转向右子树
        current = current->rchild;
    }
}

层序遍历的变种（按层输出）

void PrintByLevel(BiTree T) {
    if (T == NULL) return;
    
    Queue Q;
    InitQueue(&Q);
    EnQueue(&Q, T);
    
    while (!IsEmpty(Q)) {
        int levelSize = QueueSize(&Q);
        
        // 处理当前层的所有结点
        for (int i = 0; i < levelSize; i++) {
            BiTree current;
            DeQueue(&Q, &current);
            printf("%d ", current->data);
            
            if (current->lchild) EnQueue(&Q, current->lchild);
            if (current->rchild) EnQueue(&Q, current->rchild);
        }
        printf("\n");  // 换行表示层结束
    }
}

4. 实际应用案例

文件系统目录树

typedef struct FileNode {
    char name[256];
    bool isDirectory;
    struct FileNode* firstChild;
    struct FileNode* nextSibling;
    struct FileNode* parent;
} FileNode;

// 添加子文件/目录
void AddChild(FileNode* parent, FileNode* child) {
    child->parent = parent;
    child->nextSibling = parent->firstChild;
    parent->firstChild = child;
}

// 遍历目录（类似树的先根遍历）
void ListDirectory(FileNode* root, int depth) {
    if (root == NULL) return;
    
    // 打印缩进
    for (int i = 0; i < depth; i++) printf("  ");
    printf("%s%s\n", root->name, root->isDirectory ? "/" : "");
    
    // 递归遍历子目录
    FileNode* child = root->firstChild;
    while (child != NULL) {
        ListDirectory(child, depth + 1);
        child = child->nextSibling;
    }
}