数据结构| |对于堆的基本操作(总概括)

最新推荐文章于 2024-05-18 10:18:18 发布
最新推荐文章于 2024-05-18 10:18:18 发布
阅读量195 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40399012/article/details/81947973
版权

堆：就是完全二叉树，所以对于堆的存储可以用顺序存储来储存堆。这样便于对堆的便利与操作。
对于具有n个结点的完全二叉树，如果按照从上至下，从左至右的顺序对所有节点从0开始编号，则对于序号为i的节点有：

  1. 若i > 0，双亲序号：(i - 1) / 2; i = 0, i为根节点编号，无双亲结点
  2. 若2i + 1 < n,左孩子序号：2i + 1,否则无左孩子结点
  3. 若2i + 2 < n,右孩子序号：2i + 2,否则无右孩子结点

根据这个就可以用顺序存储更好的访问一个结点的双亲结点以及孩子结点。
堆的基本操作：

//初始化堆
void HeapInit(Heap* ph, HPDataType* a, int size);
//销毁堆
void HeapDestory(Heap* ph);
//向堆里面插入一个数据(插入到堆尾)
void HeapPush(Heap* ph, HPDataType x);
//删除一个数据(也就是删除堆顶的数据)
void HeapPop(Heap* ph);
//取出堆顶元素
HPDataType HeapTop(Heap* ph);
//判断堆是否为空
int HeapEmpty(Heap* ph);
//求堆的大小
int HeapSize(Heap* ph);
//打印堆
void HeapPrint(Heap* ph);
//采用堆排序，从小到大（采用大顶堆）
void HeapSortSmallToBig(HPDataType* a, int size);
//采用堆排序，从大到小（采用小顶堆）
void HeapSortBigToSmall(HPDataType* a, int szie);

这就是堆里面要进行的操作：
操作的实现：
头文件：Heap.h

#ifndef __HEAP_H__
#define __HEAP_H__

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>


typedef int HPDataType;

typedef struct Heap
{
    HPDataType* _a;
    int _size;
    int _capacity;
}Heap;

//初始化堆
void HeapInit(Heap* ph, HPDataType* a, int size);
//销毁堆
void HeapDestory(Heap* ph);
//向堆里面插入一个数据(插入到堆尾)
void HeapPush(Heap* ph, HPDataType x);
//删除一个数据(也就是删除堆顶的数据)
void HeapPop(Heap* ph);
//取出堆顶元素
HPDataType HeapTop(Heap* ph);
//判断堆是否为空
int HeapEmpty(Heap* ph);
//求堆的大小
int HeapSize(Heap* ph);
//打印堆
void HeapPrint(Heap* ph);
//采用堆排序，从小到大（采用大顶堆）
void HeapSortSmallToBig(HPDataType* a, int size);
//采用堆排序，从大到小（采用小顶堆）
void HeapSortBigToSmall(HPDataType* a, int size);


#endif //__HEAP_H__

接口实现：

#include "Heap.h"

//交换两个数据
void Swap(HPDataType* a, HPDataType* b)
{
    assert(a && b);

    HPDataType tmp = *a;
    *a = *b;
    *b = tmp;
}

//向下调整堆（调为大堆）
//思想：判断parent与child中较大值的结点的比较，如果parent < child，调整，
//然后在进行刚才调整过的child处的结点，直到叶子节点。结束：叶子节点的孩子结点超出数组的下标最大值
void ADJustDown(HPDataType* a, int size, int parent)
{
    assert(a);

    //左孩子结点
    int child = parent * 2 + 1;
    //左孩子结点的下标小于数组的最大下标时，堆是一个完全二叉树
    while (child < size)
    {
        //取出最大的孩子结点,只有当右孩子存在时，才能求两个中较大的一个孩子
        //在Pop的时候也有着大作用，如果没有加上的话，就有可能让Pop出现访问
        if (a[child + 1] > a[child] && ((child + 1) < size))
        {
            child++;
        }

        //交换结点，向下调整
        if (a[parent] < a[child])
        {
            Swap(&a[parent], &a[child]);
            parent = child;
            child = parent * 2 + 1;
        }

        //如果要调整的的这个结点，比起的孩子结点大的话，那就不用调整了
        else
        {
            break;
        }
    }
}

//对堆进行初始化，也就是要建堆
void HeapInit(Heap* ph, HPDataType* a, int n)
{
    assert(ph && a);

    int i = 0;
    //对堆进行初始化
    ph->_a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    for (i = 0; i < n; i++)
    {
        ph->_a[i] = a[i];
    }
    ph->_size = n;
    ph->_capacity = n;

    //调整堆
    //思路:从最后一个非叶子结点开始调整堆(向下调整)，结束：调整到堆顶
    //双亲结点等于孩子结点减一除以二
    //构建堆的时间复杂度为O(N)
    for (i = (n - 2) / 2; i >= 0; i--)
    {
        //向下调整
        ADJustDown(ph->_a, ph->_size, i);
    }

}

//对堆进行销毁
//思路：将size变为0，capacity变为0，数组指针指向的空间变为NULL
void HeapDestory(Heap* ph)
{
    assert(ph);

    free(ph->_a);
    ph->_a = NULL;
    ph->_capacity = 0;
    ph->_size = 0;
}

//从下到上调整堆
void ADJustUp(Heap* ph, int child)
{
    assert(ph);

    int parent = (child - 1) >> 1;
    //开始调整，直到child == 0
    while (child > 0)
    {
        if (ph->_a[parent] < ph->_a[child])
        {
            Swap(&ph->_a[parent], &ph->_a[child]);
            child = parent;
            parent = (child - 1) >> 1;
        }
        //如果child小于或者等于parent的话，那就不用调整堆了
        else
        {
            break;
        }
    }
}

//对堆进行插入一个元素
//思路：首先要判断堆对的空间是否已被占满，占满增容，否则进行插入
//也就是在该堆的最后一个元素进行插入，然后在进行向上调整
void HeapPush(Heap* ph, HPDataType x)
{
    assert(ph);

    //堆的空间已经满了，进行增容
    if (ph->_capacity == ph->_size)
    {
        ph->_a = (HPDataType*)realloc(ph->_a, sizeof(HPDataType) * (ph->_capacity += 4));
    }

    //先插入，从下到上调整堆
    //插入
    ph->_a[ph->_size] = x;
    ph->_size++;
    //从下到上调整堆
    ADJustUp(ph, ph->_size - 1);
}

//取出堆顶元素
//思路：将堆顶元素与最后一个元素进行交换，然后再删除最后一个元素，对于此时的堆，进行一次，向下调整即可
void HeapPop(Heap* ph)
{
    assert(ph);

    //删除堆顶元素
    Swap(&ph->_a[0], &ph->_a[ph->_size - 1]);
    ph->_size--;

    //从堆顶位置进行一次向下调整堆的操作
    ADJustDown(ph->_a, ph->_size, 0);
}

//返回堆顶元素
HPDataType HeapTop(Heap* ph)
{
    assert(ph);

    return ph->_a[0];
}

//判断队是否为空
//空 0
//非空 1 
int HeapEmpty(Heap* ph)
{
    assert(ph);

    return ph->_size == 0 ? 0 : 1;
}

//求堆的大小
int HeapSize(Heap* ph)
{
    assert(ph);

    return ph->_size;
}

//堆的输出函数
void HeapPrint(Heap* ph)
{
    assert(ph);

    for (int i = 0; i < ph->_size; i++)
    {
        printf("%d ", ph->_a[i]);
    }
    printf("\n");
}

//堆排序（从小到大）   采用大顶堆
//思想：开始讲其变为一个大顶堆，然后每次将堆顶与最后一个元素进行交换，在令该队减少一个元素再次进行
void HeapSortSmallToBig(HPDataType* a, int size)
{
    assert(a);

    int start_size = size;
    //给进来一个数组，现将该数组进行一次建堆
    for (int i = (size - 2) / 2; i >= 0; i--)
    {
        ADJustDown(a, size, i);
    }

    //当size变为0的时候，那么该堆已经变为了一个有序的序列了
    while (size > 0)
    {
        Swap(&a[0], &a[size - 1]);
        size--;

        //对于新的堆进行调整，时间复杂度O(logN)
        ADJustDown(a, size, 0);
    }
    //该函数排序函数的时间复杂度为O(NlogN)
    //调整完之后size变为了0，对于这个堆，size还应该是原来的size
    size = start_size;
}

//小顶堆从上到下，调整
void ADJustDownSmallHeap(HPDataType* a, int size, int parent)
{
    assert(a);

    //左孩子结点
    int child = parent * 2 + 1;
    //左孩子结点的下标小于数组的最大下标时，堆是一个完全二叉树
    while (child < size)
    {
        //取出最大的孩子结点,只有当右孩子存在时，才能求两个中较大的一个孩子
        //在Pop的时候也有着大作用，如果没有加上的话，就有可能让Pop出现访问
        if (a[child + 1] < a[child] && ((child + 1) < size))
        {
            child++;
        }

        //交换结点，向下调整
        if (a[parent] > a[child])
        {
            Swap(&a[parent], &a[child]);
            parent = child;
            child = parent * 2 + 1;
        }

        //如果要调整的的这个结点，比起的孩子结点大的话，那就不用调整了
        else
        {
            break;
        }
    }
}


//对数组进行排序（从大到小） 采用小顶堆
void HeapSortBigToSmall(HPDataType* a, int size)
{
    assert(a);

    int start_size = size;
    //先将该数组变为一个小顶堆
    for (int i = (size - 2) / 2; i >= 0; i--)
    {
        ADJustDownSmallHeap(a, size, i);
    }

    while (size > 0)
    {
        Swap(&a[0], &a[size - 1]);
        size--;

        //每次交换之后就要向下调整
        ADJustDownSmallHeap(a, size, 0);
    }
}

测试函数：
Test.c

#include "Heap.h"

void TestHeap()
{
    Heap hp;
    HPDataType arr[] = { 34, 35, 32, 54, 65, 87, 9, 56, 90 };
    int size = sizeof(arr) / sizeof(arr[0]);

    HeapInit(&hp, arr, size);
    HeapPrint(&hp);

    HeapPush(&hp, 100);
    HeapPrint(&hp);

    HeapPop(&hp);
    HeapPrint(&hp);

    printf("堆的堆顶元素为:%d\n", HeapTop(&hp));

    printf("堆的大小:%d\n", HeapSize(&hp));

    if (HeapEmpty(&hp))
    {
        printf("堆不为空!\n");
    }
    else
    {
        printf("堆为空!\n");
    }

    //堆排序
    //从小到大（大顶堆）
    HeapSortSmallToBig(hp._a, hp._size);
    HeapPrint(&hp);
    //从大到小
    HeapSortBigToSmall(hp._a, hp._size);
    HeapPrint(&hp);

    HeapDestory(&hp);
}

int main()
{
    TestHeap();
    return 0;
}

这就是堆这里的所有代码，欢迎大家，下载观看。

_YKitty
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
6 算法 数据结构1
08-08
算法是解决问题或完成特定任务的一系列明确、有序的操作步骤，而数据结构则是组织和存储数据的方式，使得算法能高效地运行。 **算法** 1. **什么是算法** 算法是一组有序的、有限步骤，用于解决特定问题或完成...
杭州电子科技大学数据结构(题目).pdf
04-26
1. **数据结构的定义**：数据结构可以被定义为一个三元组(D, S, P)，其中D表示数据对象，S表示这些数据对象之间的关系，P则是对这些数据执行的基本操作集合。这个定义准确概括了数据结构的核心要素。 2. **数据...
堆的基本操作
qq_37954088的博客
03-08 383
1.堆的概念       将所有元素按照完全二叉树的顺序存储方式存储在一维数组中，并且满足任意一根节点的左右子树的关键字的值小于等于根节点的值。堆实际上是一个一维数组，不过是将这个一维数组当成完全二叉树，并且认为其满足完全二叉树的双亲结点的序号和孩子结点序号的关系。 2.堆的分类       堆分为大堆和小堆。大堆，即堆顶元素是所有元素中最大的，将完全二叉树沿某条路径遍历，则得到的序列是递减...
堆的相关操作
qq_43655213的博客
03-10 182
堆堆的定义堆的类型堆结构的创建大顶堆的操作插入操作删除操作创建大顶堆取堆顶元素小顶堆的操作插入操作删除操作创建小顶堆取堆顶元素打印堆堆排序测试数据完整程序程序运行结果 堆的定义 堆（Heap）是一种数据结构，堆通常是可以被看做一棵完全二叉树的数组对象。 堆的特性 结构性：用数组表示的完全二叉树 有序性：任一节点的关键字是其子树所有节点的最大值(或最小值) 堆的类型 最大堆(MaxHeap)...
数据结构——堆的定义，堆的数据操作函数以及堆对数组的排序知识点详解！！
最新发布
hu_ju_hong的博客
05-18 990
堆和使用堆进行数组的排序知识详解！
数据结构算法之堆与二叉树查找（搜索、排序）树图解
LYR1994的博客
04-23 238
堆函数
卑鄙的我
03-15 446
一般解题过程中，我们都是手写堆和与堆相关的操作，其实STL里面已经定义了相关函数 STL中封装了有关堆操作的函数头文件：&lt;algorithm&gt; STL里面的堆操作一般用到的只有4个:make_heap();、pop_heap();、push_heap();、sort_heap(); 一、make_heap(); 他的函数原型是：void make_heap(first_poin...
堆(heap)的操作c++
陈乐乐的博客
04-19 834
堆的操作: 堆的操作函数定义在头文件 algorithm 中 以下的代码中均省略了输出的代码 vector<int> a{ 4,5,6,7,3,0,1 }; for (int i = 0; i < a.size(); i++) { cout << a[i] << ' '; } 创建堆：堆用容器vector来存放 函数：make_heap()...
数据结构期终复习参考试卷
10-20
而“数据结构知识点总结_有工大老师多年经验编写.ppt”很可能是对这些概念的精炼概括和实战案例解析，对于巩固理论知识和提高解题能力将非常有益。 在准备数据结构考试时，不仅要理解这些基本概念，还要掌握它们...
严蔚敏数据结构题集(C语言版)完整答案.doc
12-29
1. **数据结构基础**：学习数据结构，首先要理解数组、链表、栈、队列等基本概念，以及它们在存储和处理数据时的特点和应用场景。 2. **树结构**：包括二叉树、平衡树（如AVL树和红黑树）、堆等，它们在搜索、排序...
对于堆排序的一些理解！
火红的枫叶林
10-21 398
在算法导论里面提到的堆排序一共有两种方式，不过区别只是在建堆方法的不同，第一种是最大堆的方法，是将其父节点与两个子节点分别比较，然后建立一个最大堆；第二种是插入建堆的方法，是将该节点与其父节点做比较，两者区别不大，都要先建立一个最大堆。这两种方法的伪代码如下： a、HEAPIFY建堆：                                         b、INSERT建堆 MAX
堆的基本操作和应用
追梦的小蚂蚁
05-17 290
一、堆的基本操作 Heap.h #pragma once typedef int DataType; typedef int (*Compare)(DataType pLeft,DataType pRight); //表示的意思的就是接收两个指针类型的参数，返回整型的函数指针。 typedef struct Heap { DataType* _array; int _capa...
数据结构-堆的基本操作
zgege的博客
05-17 488
堆（heap）也被称为优先队列（priority queue）。队列中允许的操作是先进先出（FIFO），在队尾插入元素，在队头取出元素。而堆也是一样，在堆底插入元素，在堆顶取出元素，但是堆中元素的排列不是按照到来的先后顺序，而是按照一定的优先顺序排列的。这个优先顺序可以是元素的大小或者其他规则。如图一所示就是一个堆，堆优先顺序就是大的元素排在前面，小的元素排在后面，这样得到的堆称为最大堆。最大堆中...
堆的基本概念及常用操作
JohnSon
02-17 6350
堆 完全二叉树：若设二叉树的深度为nnn，除第nnn层外，其它各层 (111～n−1n−1n-1) 的结点数都达到最大个数，第nnn层所有的结点都连续集中在最左边，这就是完全二叉树 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为nnn，且结点总数是2n−12n−12^n - 1 ，则它就是满二叉树 堆(heap)又被为优先队列...
堆的原理及实现
Shelter
03-12 321
插入 void put(int d) { int now,next; heap[++heap_size]=d; now=heap_size; while(now&gt;1) { next=now/2; if(heap[now]&gt;heap[next]) break;//小根堆 swap(heap[now],heap[next]); now=next; } } 删...
堆的基本操作实现
cyd_csdn的博客
05-15 660
一、堆的概念        堆数据结构是一种数据对象，它可以被视为一棵完全二叉树结构。        堆的二叉树存储是：                最大堆：每个父节点都大于其孩子结点；                最小堆：每个父节点都小于其孩子结点。二、堆的实现1.堆的结构体typedef struct Heap { HeapType data[HeapMaxSize]; ...
C中对堆的操作函数
Zhangjay的专栏
03-30 975
内存区域可以分为栈，堆，静态存储区和常量存储区。局部变量，函数形参，临时变量都是在栈上获得内存的，它们获取的方式都是由编译器自动执行的。       C 标准函数库提供了许多函数来实现对堆上内存管理，其中包括：malloc函数，free函数，calloc函数和realloc函数
堆的相关运算
miqingzhiwen的博客
06-19 612
堆的相关内容： 建堆：堆是利用一个数组来进行创建的 建堆的思路：堆分为大堆和小堆，建堆时是从最后一个根节点开始进行调整，假设左右结点的堆已经满足堆的性质，所以，每进行调整一次堆的根节点之后就要向下调整。 堆的删除：当然是进行头删，这样才具有挑战性，尾删不影响堆的性质。 头删： 1.把让第一个元素的值等于最后一个元素 2.进行向下调整 3.数组的大小减1 尾插：尾插需要判断插入的数冲洗构建而成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值