【数据结构】树与树的表示、二叉树存储结构及其遍历、二叉搜索树、平衡二叉树、堆、哈夫曼树与哈夫曼编码、集合及其运算

1、树与树的表示

什么是树？

客观世界中许多事物存在层次关系

• 人类社会家谱
• 社会组织结构
• 图书信息管理

分层次组织在管理上具有更高的效率！

数据管理的基本操作之一：查找（根据某个给定关键字K，从集合R 中找出关键字与K 相同的记录）。一个自然的问题就是，如何实现有效率的查找？

• 静态查找：集合中记录是固定的，没有插入和删除操作，只有查找
• 动态查找：集合中记录是动态变化的，除查找，还可能发生插入和删除

静态查找——方法一：顺序查找（时间复杂度O(n)）

int  SequentialSearch(StaticTable * Tbl, ElementType K)
{
    // 在表Tbl[1]~Tbl[n] 中查找关键字为K的数据元素
    int  i;
    Tabl->Element[0] = K;  // 建立哨兵
    for (i = Tbl->Length; Tbl->Element[i] != K; i--)
        ;
    return  i;  // 查找成功返回所在单元下标；不成功返回0
}

静态查找——方法二：二分查找（时间复杂度O(logn)）

二分查找的启示？

　　二分查找判定树：

• 判定树上每个结点需要的查找次数刚好为该结点所在的层数
• 查找成功时查找次数不会超过判定树的深度
• n 个结点的判定树的深度为⌊log₂n⌋+1

树的定义

树（Tree）：n（n ≥ 0）个结点构成的有限集合。

　　当n = 0 时，称为空树。

　　对于任一颗非空树（n > 0），它具备以下性质：

• 树中有一个称为"根（Root）"的特殊结点，用r 表示；
• 其余结点（与r 相关联的）可分为m（m  > 0）个互不相交的有限集T₁，T₂，...，T_m，其中每个集合本身又是一颗树，称为原来树的"子树（SubTree）"。

树与非树？

• 子树是不相交的
• 除了根结点外，每个结点有且仅有一个父节点
• 一颗N个结点的树有N-1条边（我认为可以用构造性的存在性证明或是数学归纳法来证明这一点）

树的一些基本术语：

• 结点的度（Degree）：结点的子树个数
• 树的度：树的所有结点中最大的度数
• 叶结点（Leaf）：度为0的结点
• 父结点（Parent）：有子树的结点是其子树的根结点的父结点
• 子结点（Child）：若A结点是B结点的父结点，则称B结点是A结点的子结点；子结点也称孩子结点
• 兄弟结点（Sibling）：具有同一父结点的各结点彼此是兄弟结点
• 路径和路径长度：从结点n₁到n_k的路径为一个结点序列n₁，n₂，...，n_k，n_i是n_i+1的父结点，路径所包含的边的个数为路径的长度
• 祖先结点（Ancestor）：沿树根到某一结点路径上的所有结点都是这个结点的祖先结点
• 子孙结点（Descendant）：某一结点的子树中的所有结点都是这个结点子孙
• 结点的层次（Level）：规定根结点在1层，其它任一结点的层数时其父节点的层数加1
• 树的深度（Depth）：树中所有结点中的最大层次是这棵树的深度

 树的表示

为可节省空间，最常用的表示树的方法是儿子-兄弟表示法。

 2、二叉树及存储结构

二叉树的定义

二叉树T：一个有穷的结点集合

　　这个集合可以为空

　　若不为空，则它是由根结点和称为其左子树T_L和右子树T_R的两个不相交的二叉树组成

• 二叉树具有五种基本形态（空、单根、根+T_L、根+T_R、根+T_L+T_R）
• 二叉树的子树有左右顺序之分

特殊二叉树

　　斜二叉树（Skewed Binary Tree）、完美二叉树（Perfect Binary Tree）/满二叉树（Full Binary Tree）、完全二叉树（Complete Binary Tree）

　　这里重点介绍下CBT：有n 个结点的二叉树，对树中结点按从上至下、从左至右顺序进行编号，编号为i （1 ≤ i ≤ n）结点与满二叉树中编号为i 结点在二叉树中位置相同

二叉树几个重要性质

• 一个二叉树第i 层的最大结点数为：2^i-1，i ≥ 1
• 深度为k 的二叉树有最大结点总数为：2^k-1，k ≥ 1
• 对任何非空二叉树T，若n₀ 表示叶结点的个数，n₂ 是度为2 的非叶结点个数，那么两者满足关系n₀ = n₂ + 1（证明见这里）

二叉树的抽象数据类型

重要操作：

• BinTree CreateBinTree()：创建一个二叉树
• Boolean IsEmpty(BinTree BT)：判别BT 是否为空
• void Traversal(BinTree BT)：遍历，按某顺序访问每个结点

常用的遍历方法有：

• void PreOrderTraversal(BinTree BT)：先序——根、左子树、右子树
• void InOrderTraversal(BinTree BT)：中序——左子树、根、右子树
• void PostOrderTraversal(BinTree BT)：后序——左子树、右子树、根
• void LevelOrderTraversal(BinTree BT)：层次遍历——从上到下、从左到右

二叉树的存储结构

顺序存储结构

　　依完全二叉树的形式存储：按从上到下、从左到右顺序存储。

　　n 个结点的完全二叉树的节点父子关系：

• 非根节点（序号i > 1）的父结点序号是⌊i/2⌋
• 结点（序号为i）的左孩子结点的序号是2i（若2i ≤ n，否则没有左孩子）
• 结点（序号为i）的右孩子结点的序号是2i+1（若 2i+1 ≤ n，否则没有右孩子）

　　应当注意的一点是：一般二叉树也可以采用这种结构，但会造成空间浪费

链表存储

typedef  struct  TreeNode *BinTree;
typedef  BinTree Position;
struct  TreeNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
}

3、二叉树的遍历

二叉树的递归遍历

先序遍历：访问根结点；先序遍历其左子树；先序遍历其右子树

void  PreOrderTraversal(BinTree BT)
{
    if (BT)
    {
        printf ( "%d" , BT->data);
        PreOrderTraversal(BT->Left);
        PreOrderTraversal(BT->Right);
    }
}

中序遍历：中序遍历其左子树；访问根结点；中序遍历其右子树

void  InOrderTraversal(BinTree BT)
{
    if (BT)
    {
        InOrderTraversal(BT->Left);
        printf ( "%d" , BT->Data);
        InOrderTraversal(BT->Right);
    }
}

后序遍历：后续遍历其左子树；后续遍历其右子树；访问根结点

void  PostOrderTraversal(BinTree BT)
{
    if (BT)
    {
        PostOrderTraversal(BT->Left);
        PostOrderTraversal(BT->Right);
        printf ( "%d" , BT->Data);
    }
}

附注：先序、中序和后序遍历过程：遍历过程经过结点的路线一样，只是访问各结点的时机不同。下图在从入口到出口的曲线上用ⓧ、★和△三种符号分别标记出了先序、中序和后序访问各结点的时刻

先序：当曲线第一次经过一个结点时，就列出这个结点；中序：当曲线第一次经过一个树叶时，就列出这个树叶，当曲线第二次经过一个内点时就列出这个内点；后序：当曲线最后一次经过一个结点而返回这个结点的父亲时，就列出这个结点。

二叉树的非递归遍历

非递归遍历算法实现的基本思路：使用堆栈。我们以中序遍历的非递归算法为例：

• 遇到一个结点，就把它压栈，并去遍历它的左子树
• 当左子树遍历结束后，从栈顶弹出这个结点并访问它
• 然后按其右指针再去中序遍历该结点的右子树

void  InOrderTraversal(BinTree BT)
{
    BinTree T = BT;
    Stack S = CreateStack(MaxSize);  // 创建并初始化堆栈
    while (T || !IsEmpty(S))
    {
        while (T)  // 一直向左并将沿途结点压入堆栈
        {
            Push(S, T);
            T = T->Left;
        }
        if (!IsEmpty(S))  // 不是必须的，因为while入口处已经判断过了
        {
            T = Pop(S);  // 结点弹出堆栈
            printf ( "%5d" , T->Data);  // (访问)打印结点
            T = T->Right;  // 转向右子树
        }
    }
}

注意到先序的非递归算法只要在中序非递归算法的基础上做一下调整就好了：printf语句放到Push操作之前。而后续遍历就比较繁琐了，因为当指针T指向一个结点时，不能马上对它进行访问，而要先遍历它的左子树，因而要将此结点的地址进栈保存。当其左子树遍历完毕之后，再次搜索到该结点时（退栈），还不能对它访问，还需要遍历它的右子树，所以，再一次将此结点的地址进栈保存。为了区别同一结点的两次进栈，需要引入一个标志变量，比如flag为0表示该结点暂不访问，为1表示该结点可以访问。

层序遍历

层序遍历基本过程：先根结点入队，然后：

• 从队列中取出一个元素
• 访问该元素所指结点
• 若该结点所指结点的左、右孩子结点非空，则将其左、右孩子的指针顺序入队

void  LevelOrderTraversal(BinTree BT)
{
    Queue Q;
    BinTree T;
    if (!BT)  // 若是空树直接返回
        return ;
    Q = CreateQueue(MaxSize);  // 创建并初始化队列Q
    AddQ(Q, BT);
    while (!IsEmpty(Q))
    {
        T = Delete(Q);
        printf ( "%d\n" , T->Data);  // 访问取出队列的结点
        if (T->Left)
            AddQ(Q, T->Left);
        if (T->Right)
            AddQ(Q, T->Right);
    }
}

遍历二叉树的应用

输出二叉树中的叶子结点

　　在二叉树的遍历算法中增加检测结点的"左右子树是否都为空"

void  PreOrderPrintLeaves(BinTree BT)
{
    if (BT)
    {
        if (!BT->Left && !BT->Right)
            printf ( "%d" , BT->Data);
        PerOrderPrintLeaves(BT->Left);
        PerOrderPrintLeaves(BT->Right);
    }
}

求二叉树的高度

　　需要注意到Height = Max(H_L, H_R) + 1

int  PostOrderGetHeight(BinTree BT)
{
    int  HL, HR, MaxH;
    if (BT)
    {
        HL = PostOrderGetHeight(BT->Left);  // 求左子树的深度
        HR = PostOrderGetHeight(BT->Right);  // 求右子树的深度
        MaxH = (HL > HR) ? HL : HR;  // 取左右子树中较大的深度
        return  MaxH + 1;  // 返回树的深度
    }
    else
        return  0;  // 空树深度为0
}

由先序和中序遍历序列来确定一颗二叉树

• 根据先序遍历序列第一个结点确定根结点
• 根据根结点在中序遍历序列中的位置分隔出左右两个子序列
• 对左子树和右子树分别递归使用相同的方法继续分解

　　类似地，后序和中序遍历序列也可以确定一颗二叉树

4、二叉搜索树

先来回顾一下之前提到的查找问题（静态查找与动态查找），针对动态查找，数据如何组织？

什么是二叉搜索树

二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树：一颗二叉树，可以为空；如果不为空，满足以下性质：

• 非空左子树的所有键值小于其根结点的键值
• 非空右子树的所有键值大于其根结点的键值
• 左、右子树都是二叉搜索树

二叉搜索树操作的特别函数

• Postion Find(ElementType X, BinTree BST)：从二叉搜索树BST中查找元素X，返回其所在结点的地址
• Postion FindMin(BinTree BST)：从二叉搜索树BST中查找并返回最小元素所在结点的地址
• Position FindMax(BinTree BST)：从二叉搜索树BST中查找并返回最大元素所在结点的地址
• BinTree Insert(ElementType X, BinTree BST)
• BinTree Delete(ElementType X, BinTree BST)

二叉搜索树的查找操作：Find

• 查找从根结点开始，如果树为空，返回NULL
• 若搜索树非空，则根结点关键字和X进行比较，并进行不同处理：

　　　　　　若X小于根结点键值，只需在左子树中继续搜索

　　　　　　若X大于根结点的键值，在右子树中继续进行搜索

　　　　　　若两者比较结果相等，搜索完成，返回指向此结点的指针。

Positon Find(ElementType X, BinTree BST)
{
    if (!BST)
        return  NULL;  // 查找失败
    if (X > BST->Data)
        return  Find(X, BST->Right);  // 在右子树中继续查找
    else  if
        return  Find(X, BST->Left);  // 在左子树中继续查找
    else  // X == BST->Data
        return  BST;  // 查找成功，返回结点的地址
}

上面程序中的两处递归调用都是尾递归，因此可以方便的改写为迭代函数，以便提高执行效率（注意到，查找的效率取决于树的高度）

Position IterFind(ElementType X, BinTree BST)
{
    while (BST)
    {
        if (X > BST->Data)
            BST = BST->Right;  // 向右子树中移动，继续查找
        else  if (X < BST->Data)
            BST = BST->Left;  // 向左子树中移动，继续查找
        else  // X == BST->Data
            return  BST;  // 查找成功，返回结点的地址
    }
    return  NULL;  // 查找失败
}

查找最大和最小元素

　　只需注意到以下事实：

• 最大元素一定在树的最右分支的端结点上
• 最小元素一定在树的最左分支的端节点上

查找最小元素的递归函数

Postion FindMin(BinTree BST)
{
    if (!BST)
        return  NULL;  // 空的二叉搜索树，返回NULL
    else  if (!BST->Left)
        return  BST;  // 找到最左叶结点并返回
    else
        return  FindMin(BST->Left);  // 沿左分支继续查找
}

查找最大元素的迭代函数

Position FindMax(BinTree BST)
{
    if (BST)
        while (BST->Right)
            BST = BST->Right;  // 沿右分支继续查找，直到最右结点
    return  BST;
}

二叉搜索树的插入

　　关键是要找到元素应该插入的位置，可以采用与Find类似的方法

BinTree Insert(ElementType X, BinTree BST)
{
    if (!BST)
    {
        // 若原树为空，生成并返回一个结点的二叉搜索树
        BST =  malloc ( sizeof ( struct  TreeNode));
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    }
    else  // 开始找要插入元素的位置
    {
        if (X < BST->Data)
            BST->Left = Insert(X, BST->Left);  // 递归插入左子树
        else  if (X > BST->Data)
            BST->Right = Insert(X, BST->Right);  // 递归插入右子树
        // else X已经存在，什么都不做
    }
    return  BST;
}

关于上面的代码，多说一点，就是关于递归调用返回的时候需要赋值给左子树或右子树，这在大多数赋值的情况下显得多余（就像是说，把当前树的左子树赋值给它的左子树），但是它是必须的，因为在插入元素的时候我们需要知道它的父结点的左指针或右指针。我们也可以消除不必要的赋值，但是它是以增加逻辑判断为代价的，还不如原先的方式显得清晰、美观。

二叉搜索树的删除

　　要考虑三种情况

• 要删除的是叶节点：直接删除，并再修改其父结点指针，置为NULL
• 要删除的结点只有一个孩子结点：将其父结点的指针指向要删除结点的孩子结点
• 要删除的结点有左、右两颗子树：用另一结点替代被删除结点：右子树的最小元素或者左子树的最大元素

BinTree Delete(ElementType X, BinTree BST)
{
    Position Tmp;
    if (!BST)
        printf ( "要删除的元素未找到" );
    else  if (X < BST->Data)
        BST->Left = Delete(X, BST->Left);  // 左子树递归删除
    else  if (X > BST->Data)
        BST->Right = Delete(X, BST->Right);  // 右子树递归删除
    else  // 找到要删除的结点
    {
        if (BST->Left && BST->Right)  // 被删除结点有左右两个子结点
        {
            Tmp = FindMin(BST->Right);  // 在右子树中找最小的元素填充删除结点
            BST->Data = Tmp->Data;
            BST->Right = Delete(BST->Data, BST->Right);  // 在删除结点的右子树中删除最小元素
        }
        else  // 被删除结点有一个或无子结点
        {
            Tmp = BST;
            if (!BST->Left)  // 有右孩子或无子结点
                BST = BST->Right;
            else  if (!BST->Right)  // 有左孩子或无子结点
                BST = BST->Left;
            free (Tmp);
        }
    }
    return  BST;
}

 5、平衡二叉树

什么是平衡二叉树

搜索树结点不同插入次序，将导致不同的深度和平均查找程度，这促使二叉树"平衡"这个概念的出现。二叉树平衡与否的度量由"平衡因子"（Balance Factor，简称BF：BF(T) = H_L - H_R，其中H_L和H_R分别为T的左、右子树的高度）来决定。

平衡二叉树（Balanced Binary Tree）（AVL树）：

　　空树，或者任一结点左、右子树高度差的绝对值不超过1，即|BF(T)| ≤ 1

我们之所以想要二叉树在一定程度上达到平衡，就是奔着它的效率去的，那么很自然的一个问题是：平衡二叉树的高度能达到log₂n吗？

设n_h 为高度为h 的平衡二叉树的最少结点数。结点数最少时：n_h = n_h-1 + n_h-2 + 1。

可以看到，其形式非常类似于斐波那契数列。我们结合初始条件n₀ = 1，n₁ = 2不难得出n_h = F_h+2 - 1。于是我们可以说h = O(log₂n)。通俗的说就是，给定结点数为n 的AVL树的最大高度为O(log₂n)。

平衡二叉树的调整

AVL树的调整分为四种情况，分别为左单旋、右单旋、左右双旋、右左双旋。值得注意的一点是：有时候插入元素即便不需要调整结构，也可能需要重新计算一些平衡因子。

何老师给的图很好，简洁明了的表达了需要调整的情况并且给出了具体调整的方法：

下面是程序实现：

typedef  struct  AVLTreeNode *AVLTree;
typedef  struct  AVLTreeNode{
    ElementType Data;
    AVLTree Left;
    AVLTree Right;
    int  Height;
};

AVLTree AVL_Insertion(ELementType X, AVLTree T)
{
    // 将X插入AVL树中，并且返回调整后的AVL树
    if (!T)  // 若插入空树，则新建一个包含一个结点的树
    {
        T = (AVLTree)  malloc ( sizeof ( struct  AVLTreeNode));
        T->Data = X;
        T->Height = 0;
        T->Left = T->Right = NULL;
    }  // if(插入空树)结束
    else  if (X < T->Data)  // 插入T的左子树
    {
        T->Left = AVL_Insertion(X, T->Left);
        if (GetHeight(T->Left) - GetHeight(T->Right) == 2)
        {
            // 需要左旋
            if (X < T->Left->Data)
                T = SingleLeftRotation(T);  // 左单旋
            else
                T = DoubleLeftRightRotation(T);  // 左-右双旋
        }
    }  // else if(插入左子树)结束
    else  if (X > T->Data)  // 插入T的右子树
    {
        T->Right = AVL_Insertion(X, T->Right);
        if (GetHeight(T->Left) - GetHeight(T->Right) == -2)
        {
            // 需要右旋
            if (X > T->Right->Data)
                T = SingleRightRotation(T);  // 右单旋
            else
                T = DoubleRightLeftRotation(T);  // 右-左双旋
        }
    }  //else if(插入右子树)结束

    // else X == T->Data, 无须插入

    T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1;  // 更新树高

    return  T;
}

AVLTree SingleLeftRotation(AVLTree A)
{
    // 注意：A必须有一个左子结点B
    // 将A与B做如图所示的左单旋，更新A与B的高度，返回新的根结点B
    AVLTree B = A->Left;
    A->Left = B->Right;
    B->Right = A;
    A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
    B->Height = Max(GetHeight(B->Left), A->Height) + 1;

    return  B;
}

AVLTree DoubleLeftRightRotation(AVLTree A)
{
    // 注意：A必须有一个左子结点B，且B必须有一个右子结点C
    // 将A、B与C做如图所示的两次单旋，返回新的根结点C
    A->Left = SingleRightRotation(A->Left);  // 将B与C做右单旋，C被返回

    return  SingleLeftRotationO(A);  // 将A与C做左单旋，C被返回
}

6、堆　

什么是堆

　　优先队列（Priority Queue）：特殊的"队列"，取出元素的顺序是依照元素的优先权（关键字）的大小，而不是元素进入队列的先后顺序。

　　问题：如何组织优先队列？

• 一般的数组、链表？
• 有序的数组、链表？
• 二叉搜索树？AVL树？

　　对于堆来说，主要就是两个操作，插入和删除，而无论是一般的数组、链表，还是有序的数组、链表其中至少有一个操作是需要O(n) 的时间来完成的。可以考虑能否采用二叉树存储结构？如果采用这种存储结构的话，我们更应该关注插入还是删除操作？树结点顺序怎么安排？树结构怎样？

　　堆的两个特性：

• 结构性：用数组表示的完全二叉树
• 有序性：任一结点的关键字是其子树所有结点的最大值（或最小值）

堆的抽象数据类型

以最大堆为例，其主要操作有：

• MaxHeap Create(int MaxSize)：创建一个空的最大堆
• Boolean IsFull(MaxHeap H)：判断最大堆H是否已满
• void Insert(MaxHeap H, ElementType item)：将元素item插入最大堆H
• Boolean IsEmpty(MaxHeap H)：判断最大堆是否为空
• ElementType DeleteMax(MaxHeap H)：返回H中最大元素（高优先级）

 最大堆的创建

typedef  struct  HeapStruct *MaxHeap;
struct  HeapStruct{
    ElementType *Elements;  // 存储堆元素的数组
    int  Size;  // 堆的当前元素个数
    int  Capacity;  // 堆的最大容量
}

MaxHeap Create( int  MaxSize)
{
    // 创建容量为MaxSize的空的最大堆
    MaxHeap H =  malloc ( sizeof ( struct  HeapStruct));
    H->Elements =  malloc ((MaxSize+1) *  sizeof (ElementType));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Elements[0] = MaxData;  // 定义"哨兵"为大于堆中所有可能元素的值，便于以后更快操作
    return  H;
}

注意到，把MaxData换成小于堆中所有元素的MinData，同样适用于创建最小堆。

最大堆的插入

　　思路：首先默认插入位置在完全二叉树的下一个位置，通过向下过滤结点的方式，从其父结点到根结点的有序序列中寻找合适的位置进行插入操作

void  Insert(MaxHeap H, ElementType item)
{
    // 将元素item插入最大堆H，其中H->Elements[0]已经定义为哨兵
    int  i;
    if (IsFull(H))
    {
        printf ( "最大堆已满" );
        return ;
    }
    i = ++H->Size;  // i指向插入后堆中的最后一个元素的位置
    for (; H->Elements[i/2] < item; i /= 2)
        H->Elements[i] = H->Elements[i/2];  // 向下过滤结点，这种方式比交换数据来得快
    H->Elements[i] = item;  // 将item插入
}

上述代码中，H->Elements[0]是哨兵元素，它不小于堆中的最大元素，控制循环结束。时间复杂度O(logN)。

最大堆的删除

　　思路：取出根结点（最大值），同时删除它，方法就是用堆中的最后一个元素代替之（和插入操作一样，这里的代替只是形式上方便理解的说辞，实际上我们只是用一个临时变量保存其值而已，这比真实的替代更省时），但是其位置不一定正确，因此需要从根结点开始向上过滤下层结点。

ElementType DeleteMax(MaxHeap H)
{
    // 从最大堆H中取出键值为最大的元素，并删除一个结点
    int  Parent, Child;
    ElementType MaxItem, temp;
    if (IsEmpty(H))
    {
        printf ( "最大堆已为空" );
        return ;
    }
    MaxItem = H->Elements[1];  // 取出根结点最大值
    // 用最大堆中最后一个元素从根结点开始向上过滤下层结点