【数据结构初学笔记14】第五章堆、哈夫曼树、集合

1.堆

主要包括：堆的存储结构，创建最大（小）空堆，最大（小）堆的插入和删除，建立最大（小）堆的更优方法。

//堆：1完全二叉树表示，2任一结点的元素值是其子树所有结点的最大值或最小值
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define ElementType int
#define MaxData 1000 //哨兵元素应大于或小于堆中所有可能的元素
#define MinData -10  //哨兵元素应大于或小于堆中所有可能的元素
#define ERROR -1     /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */
// 01堆的存储表示:因为堆为完全二叉树结构，故可以使用顺序存储结构来表示。
typedef struct HeapStruct *HeapTree;
typedef HeapTree MaxHeap; /* 最大堆 */
typedef HeapTree MinHeap; /* 最小堆 */
struct HeapStruct
{
    ElementType *Elements; //存储堆元素的数组指针
    int Size;              //堆当前元素的个数
    int Capacity;          //堆的最大容量
};
int main(void)
{

    return 0;
}
int IsFull(HeapTree H) //判断堆是否满，满堆返回1
{
    return (H->Size == H->Capacity);
}
int IsEmpty(HeapTree H) //判断堆是否空，空堆返回1
{
    return (H->Size == 0);
}
// 02创建最大堆
HeapTree CreateHeapMax(int Maxsize) //创建容量为Maxsize的空堆
{
    HeapTree H = (HeapTree)malloc(sizeof(struct HeapStruct));
    H->Elements = (ElementType *)malloc(sizeof(ElementType) * (Maxsize + 1));
    H->Size = 0;
    H->Capacity = Maxsize;
    H->Elements[0] = MaxData; //定义哨兵
    return H;
}
// 02创建最小堆
HeapTree CreateHeapMin(int Maxsize) //创建容量为Maxsize的空堆
{
    HeapTree H = (HeapTree)malloc(sizeof(struct HeapStruct));
    H->Elements = (ElementType *)malloc(sizeof(ElementType) * (Maxsize + 1));
    H->Size = 0;
    H->Capacity = Maxsize;
    H->Elements[0] = MinData; //定义哨兵
    return H;
}
// 03最大堆的插入
void InsertMax(HeapTree H, ElementType item) //将元素item插入到最大堆H中，其中哨兵为H->ElementType[0]
{
    int i;
    if (IsFull(H))
    {
        printf("堆已满\n");
        return;
    }
    i = ++H->Size;
    for (; H->Elements[i / 2] < item; i = i / 2)
    {
        H->Elements[i] = H->Elements[i / 2]; //向下过滤比插入值小的结点
    }
    H->Elements[i] = item; // item的插入位置
}
// 03最小堆的插入
void InsertMin(HeapTree H, ElementType item) //将元素item插入到最大堆H中，其中哨兵为H->ElementType[0]
{
    int i;
    if (IsFull(H))
    {
        printf("堆已满\n");
        return;
    }
    i = ++H->Size;
    for (; H->Elements[i / 2] > item; i = i / 2)
    {
        H->Elements[i] = H->Elements[i / 2]; //向下过滤比插入值小的结点
    }
    H->Elements[i] = item; // item的插入位置
}
// 04最大堆的删除
ElementType DeleteMax(HeapTree H) //从最大堆H中取出键值最大的元素，并删除该结点
{                                 //方法：用最大堆中的最后一个元素，从根结点从上到下过滤元素
    int Parent, Child;
    ElementType Maxitem, temp;
    if (IsEmpty(H))
    {
        printf("最大堆为空\n");
        return ERROR;
    }
    Maxitem = H->Elements[1];
    /* 用最大堆中最后一个元素从根结点开始向上过滤下层结点 */
    temp = H->Elements[H->Size--];                          /* 注意当前堆的规模要减小 */
    for (Parent = 1; 2 * Parent <= H->Size; Parent = Child) // 2*Parent<=Size是为了确保它有孩子结点，以继续进行比较。
    {
        Child = 2 * Parent;
        if ((Child != H->Size) && (H->Elements[Child] < H->Elements[Child + 1])) //找出左右孩子中较大那个
        {
            Child++; /* Child指向左右子结点的较大者 */
        }
        if (temp >= H->Elements[Child]) //不用继续往下比较了，可能到了末尾结点或者该子树的元素都比item要小。
            break;
        else /* 下滤X */
        {
            H->Elements[Parent] = H->Elements[Child];
        }
    }
    H->Elements[Parent] = temp;
    return Maxitem;
}
// 04最小堆的删除
ElementType DeleteMin(HeapTree H) //从最小堆H中取出键值最小的元素，并删除该结点
{                                 //方法：用最小堆中的最后一个元素，从根结点从上到下过滤元素
    int Parent, Child;
    ElementType Minitem, temp;
    if (IsEmpty(H))
    {
        printf("最小堆为空\n");
        return ERROR;
    }
    Minitem = H->Elements[1];
    /* 用最小堆中最后一个元素从根结点开始向上过滤下层结点 */
    temp = H->Elements[H->Size--];                          /* 注意当前堆的规模要减小 */
    for (Parent = 1; 2 * Parent <= H->Size; Parent = Child) // 2*Parent<=Size是为了确保它有孩子结点，以继续进行比较。
    {
        Child = 2 * Parent;
        if ((Child != H->Size) && (H->Elements[Child] > H->Elements[Child + 1])) //找出左右孩子中较小那个
        {
            Child++; /* Child指向左右子结点的较小者 */
        }
        if (temp <= H->Elements[Child]) //不用继续往下比较了，可能到了末尾结点或者该子树的元素都比item要大。
            break;
        else /* 下滤X */
        {
            H->Elements[Parent] = H->Elements[Child];
        }
    }
    H->Elements[Parent] = temp;
    return Minitem;
}
//05建立最大堆：建立一个完全二叉树，从最后一个有儿子的父结点开始逐个往前建堆，将每一个子堆都调整为最大堆，调的方法与删除堆顶元素的方法类似
//此方法相较于逐个元素插入的方法，可以降低时间复杂度，NlogN->N
/*----------- 建造最大堆 -----------*/
void PercDownMax(HeapTree H, int p)
{ /* 下滤：将H中以H->Data[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;

    X = H->Elements[p]; /* 取出根结点存放的值 */
    for (Parent = p; Parent * 2 <= H->Size; Parent = Child)
    {
        Child = Parent * 2;
        if ((Child != H->Size) && (H->Elements[Child] < H->Elements[Child + 1]))
            Child++; /* Child指向左右子结点的较大者 */
        if (X >= H->Elements[Child])/* 找到了合适位置 */
            break; 
        else       /* 下滤X */
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = X;
}
void BuildHeapMax(HeapTree H)
{ /* 调整H->Elements[]中的元素，使满足最大堆的有序性  */
    /* 这里假设所有H->Size个元素已经存在H->Data[]中 */
    int i;
    /* 从最后一个结点的父节点开始，到根结点1 */
    for (i = H->Size / 2; i > 0; i--)
        PercDownMax(H, i);
}
//05建立最小堆：建立一个完全二叉树，从最后一个有儿子的父结点开始逐个往前建堆，将每一个子堆都调整为最小堆，调的方法与删除堆顶元素的方法类似
//此方法相较于逐个元素插入的方法，可以降低时间复杂度，NlogN->N
/*----------- 建造最小堆 -----------*/
void PercDownMin(HeapTree H, int p)
{ /* 下滤：将H中以H->Data[p]为根的子堆调整为最小堆 */
    int Parent, Child;
    ElementType X;

    X = H->Elements[p]; /* 取出根结点存放的值 */
    for (Parent = p; Parent * 2 <= H->Size; Parent = Child)
    {
        Child = Parent * 2;
        if ((Child != H->Size) && (H->Elements[Child] > H->Elements[Child + 1]))
            Child++; /* Child指向左右子结点的较小者 */
        if (X <= H->Elements[Child])/* 找到了合适位置 */
            break; 
        else       /* 下滤X */
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = X;
}
void BuildHeapMin(HeapTree H)
{ /* 调整H->Elements[]中的元素，使满足最小堆的有序性  */
    /* 这里假设所有H->Size个元素已经存在H->Data[]中 */
    int i;
    /* 从最后一个结点的父节点开始，到根结点1 */
    for (i = H->Size / 2; i > 0; i--)
        PercDownMin(H, i);
}

2.哈夫曼树

主要包括：哈夫曼树的存储结构，从一个完全二叉树建立哈夫曼树的方法。

/*哈夫曼树：带权路径长度WPL最小的二叉树*/
/*建立方法：首先将所有元素建立一个完全二叉树，采用顺序存储，Elements每个元素采用哈夫曼结点的结构，一个Element包含权值Weight，左右哈夫曼子树默认为NULL*/
/*将完全二叉树建立为最小堆;每次删除两个最小堆堆顶元素，设计一个新哈夫曼结点指向这两个堆顶元素，并计算新哈夫曼结点的权重，将新哈弗曼结点插入最小堆中*/
/*一共要做H->Size-1次合并，最后最小堆只剩一个堆顶元素，删除最小堆操作返回一个哈夫曼树的根节点指针*/
#include <stdio.h>
#include <stdlib.h>
typedef struct TreeNode *HuffmanTree;
struct TreeNode
{
    int Weight;
    HuffmanTree Left, Right;
};
HuffmanTree Huffman(MinHeap H)
{ /*H是一个完全二叉树，假设H->size个权值已经存放在H->Elements[]->Weight里*/
    int i;
    HuffmanTree T;
    BuildMinHeap(H); /*将H->Elements[]按权值调整为最小堆*/
    for(i=1;i<H->Size;i++)
    {/*做H->Size-1次合并*/
        T=(HuffmanTree)malloc(sizeof(struct TreeNode));
        T->Left=DeleteMin(H);
        /*从最小堆中删除一个结点，作为新T的右子结点*/
        T->Right=DeleteMin(H);
        /*从最小堆中删除一个结点，作为新T的右子结点*/
        T->Weight=T->Left->Weight+T->Right->Weight;
        /*计算新权值*/
        Insert(H,T);/*将新T插入到最小堆*/
    }
    T=DeletMin(H);
    return T;
}

3.集合

主要包括：集合结点的存储方法，集合的查找运算，并运算。

#include <stdio.h>
#include <stdlib.h>
#define ElementType int
#define MaxSize 100 /*数组的最大长度*/
typedef struct
{
    ElementType Data;
    int Parent
} SetType;
// 01查找某个元素所在的集合（用根节点表示）
int Find(SetType S[], ElementType X)
{ /*在数组s中查找值为X的元素所属的集合*/
    int i;
    for (i = 0; i < MaxSize && S[i].Data != X; i++)
    {
        if (i >= MaxSize)
            return -1; /*未找到X，返回-1*/
    }
    for (; S[i].Parent >= 0; i = S[i].Parent)
        ;
    return i; /*找到了X所属集合，返回树根节点在数组S中的下标*/
}
// 02集合的并运算
void Union(SetType S[], ElementType X1, ElementType X2)
{
    int Root1, Root2;
    Root1 = Find(S, X1);
    Root2 = Find(S, X2);
    if (Root1 != Root2) /*保证不是同一个集合*/
    {
        if (S[Root1].Parent >= S[Root2].Parent) /*集合1更大，将集合2合并到集合1中，以优化集合结构，提高Find函数的效率*/
        {
            S[Root1].Parent += S[Root2].Parent;
            S[Root2].Parent = Root1;
        }
        else /*集合1小于集合2的情况*/
        {
            S[Root2].Parent += S[Root1].Parent;
            S[Root1].Parent = Root2;
        }
    }
}

 

结束

课程来源：浙江大学数据结构慕课MOOC