一文读懂特殊的树结构——堆

最新推荐文章于 2024-06-25 09:28:35 发布

书山客

最新推荐文章于 2024-06-25 09:28:35 发布

阅读量282

点赞数

分类专栏：数据结构与算法文章标签：二叉树算法数据结构堆排序 c语言

本文链接：https://blog.youkuaiyun.com/qq_40344524/article/details/108749924

版权

数据结构与算法专栏收录该内容

12 篇文章

订阅专栏

本文详细介绍了堆这一数据结构，包括堆的定义、性质和两种类型：大顶堆与小顶堆。通过C语言实现了堆的构造、初始化、插入节点、删除节点以及堆排序等基本操作，并探讨了堆在优先队列和排序算法中的应用。堆排序是一种高效的排序算法，通过构建大顶堆来找到序列中的最大值并逐步构建有序序列。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

专栏目录（数据结构与算法解析）：https://blog.youkuaiyun.com/qq_40344524/article/details/107785323

堆（完全二叉树）

定义

堆是计算机科学中一类特殊的数据结构的统称。n个元素的序列{k1,k2,ki,…,kn}当且仅当满足(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2)时，称之为堆。若将和此次序列对应的一维数组（即以一维数组作此序列的存储结构）看成是一个完全二叉树，则堆的含义表明，完全二叉树中所有非终端结点的值均不大于（或不小于）其左、右孩子结点的值。由此，若序列{k1,k2,…,kn}是堆，则堆顶元素（或完全二叉树的根）必为序列中n个元素的最小值（或最大值）。

堆通常是一个可以被看做一棵树（完全二叉树）的数组对象。根据结点特征可以将堆分为大顶堆和小顶堆两种，将根节点最大的堆叫做最大堆或大顶堆，根节点最小的堆叫做最小堆或小顶堆。

性质

1.堆中某个节点的值总是不大于或不小于其父节点的值。
2.堆总是一棵完全二叉树。

堆的结构

typedef struct HNode * Heap; //堆的类型定义
struct HNode{
	ElementType *Data; //存储元素的数组 
	int Size;          //堆中当前元素的个数 
	int Capacity;	   //堆的最大容量 
};
typedef Heap MaxHeap;  //最大堆 
typedef Heap MinHeap;  //最小堆

基本操作

1、堆的构造
2、堆的初始化
3、插入节点
4、删除节点
5、堆排序

代码实现

接下来通过C语言实现堆的基本操作，以下讲解均以原始数据为a[]={4,1,3,2,16,9.10.14.8.7}为基础，实现的操作在最大堆上进行。

1、堆的构造

数据结构如下：

typedef struct HNode * Heap; //堆的类型定义
struct HNode{
	ElementType *Data; //存储元素的数组 
	int Size;          //堆中当前元素的个数 
	int Capacity;	   //堆的最大容量 
};
typedef Heap MaxHeap;  //最大堆

2、堆的初始化

基本思想：首先将每个叶子结点视为一个堆，再将每个叶子结点于其父节点一起构成一个包含更多结点的堆。所以在构造堆的时候，首先需要找到最后一个结点的父节点，从这个节点开始构造最大堆，直到该节点前面的所有分支节点都处理完毕，具体过程可用如下代码表示。

void MaxHeapInit(MaxHeap &H)
{
    for(int i=H.HeapSize/2;i>=1;i--)
    {
        H.heap[0]=H.heap[i];
        int son=i*2;
        while(son<H.HeapSize)
        {
            if(son<H.HeapSize&&H.heap[son]<H.heap[son+1])
                son++;
            if(H.heap[i]>H.heap[son])
                break;
            else if(son<H.heapSize&&H.heap[son]>H.heap[son+1]
                {
                    H.heap[son/2]=H.heap[son];
                    son*=2;
                }
        }
        H.heap[son/2]=H.heap[0];
    }
}

注意：在二叉树中，若当前节点的下标为 i，则其父节点的下标为 i/2，其左子节点的下标为 i2，其右子节点的下标为i2+1；

3、插入节点

最大堆中插入节点，先在堆末尾插入该节点，然后按照堆的初始化过程将该节点放入到合适的位置。

void MaxHeapInsert(MaxHeap &H, EType &x)
{
    if(H.HeapSize==H.MaxSize) return false;
    
    int i=++H.HeapSize;
    while(i!=1&&x>H.heap[i/2])
    {
        H.heap[i]=H.heap[i/2];
        i/=2;
    }
    H.heap[i]=x;
    return true;
}

4、删除节点

将最大堆的最后一个节点放到根节点，然后删除最大值，然后再把新的根节点放到合适的位置

void MaxHeapDelete(MaxHeap &H, EType &x)
{
    if(H.HeapSize==0) return false;
    x=H.heap[1];
    H.heap[0]=H.heap[H.HeapSize--];
    int i=1, son=i*2;
     while(son<H.HeapSize)
        {
            if(son<H.HeapSize&&H.heap[son]<H.heap[son+1])
                son++;
            if(H.heap[i]>H.heap[son])
                break;
             H.heao[i]=H.heap[son];
            i=son;
            son*=2;
        }
        H.heap[i]=H.heap[0];
    return true;
    
}

5、堆排序

1、将带排序的序列构造成一个大顶堆，根据大顶堆的性质，当前堆的根节点（堆顶）就是序列中最大的元素；2、将堆顶元素和最后一个元素交换，然后将剩下的节点重新构造成一个大顶堆；3、重复步骤2，如此反复，从第一次构建大顶堆开始，每一次构建，我们都能获得一个序列的最大值，然后把它放到大顶堆的尾部。最后，就得到一个有序的序列了。


#include<iostream>
using namespace std;
 
void swap(int &a, int &b)
{
    int temp=a;
    a=b;
    b=temp;
}
 
void quick_build(int a[], int len, int root)
{
    int left=root*2+1;
    int flag=left;
    while(left<len)
    {
        int right=left+1;
        while(right<len&&a[right]>a[left])
            flag=right;
        
    }
    if(a[root]<a[flag])
    {
        swap(a[root],a[flag]);
        heap_build(a,len,flag);
}
 
void quick_sort(int a[], int len)
{
    for(int i=len/2;i>0;i--)
        heap_build(a,len, i);
    for(int j=len-1;j>0;j--)
    {
        swap(a[0],a[j]);
        heap_build(a,0,j);
    }  
        
}