堆排序

最新推荐文章于 2023-05-28 11:19:59 发布
最新推荐文章于 2023-05-28 11:19:59 发布
阅读量88 收藏
点赞数
分类专栏： 数据结构算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40285044/article/details/80645594
版权

方法一

//一个大顶堆的例子

#include <iostream>
#include <algorithm>
using namespace std;


const int maxsize = 100;
int heap[maxsize];
int size = 0;


//在堆heap中插入data
void insertHeap(int *heap, int data);
//获得最大值
int getMax(int *heap);
//从堆中删除最大值
void deleteMax(int *heap);


int main()
{
    int buf[8] = {16, 21, 12, 30, 13, 15, 10, 25};
    for (int i = 0; i < 8; i++)
    {
        insertHeap(heap, buf[i]);
    }
    while (size > 0)
    {
        cout << getMax(heap) << " ";
        deleteMax(heap);
    }
    return 0;
}


//获得最大值
int getMax(int *heap)
{
    return heap[0];
}


//在堆heap中插入data
void insertHeap(int *heap, int data)
{//新加入的元素放在数组的最后
    int k = size;
    heap[k] = data;
    size++;
    //上筛
    while (k > 0)
    {//如果没有到达根结点，继续上筛
        int parent = (k - 1) / 2;//得到父节点的下标
        if (heap[parent] > heap[k])
        {//如果父节点的值大于新加入元素的值，堆序性存在，退出循环
            break;
        }
        swap(heap[parent], heap[k]);//交换heap[parent]和heap[k]
        k = parent;
    }
}


//从堆中删除最大值
void deleteMax(int *heap)
{
    swap(heap[0], heap[size - 1]);//交换堆顶和堆的最后一个元素
    --size;//删除堆中的最后一个元素
    //下筛
    int parent = 0;
    int left = 2 * parent + 1;
    while (left < size)
    {//当左子树的编号在堆的下标范围之内，说明parent是叶子结点
        int k;
        int right = left + 1;
        if (right >= size)
        {//没有右孩子
            if (heap[parent] > heap[left])
            {//父结点的值大于左孩子的值，堆序性存在
                break;
            }
            k = left;
            swap(heap[parent], heap[k]);//交换父结点和左孩子的值
        }
        else
        {//有左右孩子
            if (heap[parent] > heap[left] && heap[parent] > heap[right])
            {//父结点的值大于左右孩子的值，堆序性存在
                break;
            }
            //把父结点的值和左右孩子中最大的值交换
            k = heap[left] > heap[right] ? left : right;
            swap(heap[parent], heap[k]);
        }

        parent = k;//下一次要下筛的结点编号

        left = 2 * parent + 1;
    }

}

方法二

//一个大顶堆的例子
#include <iostream>
#include <algorithm>
using namespace std;


const int maxsize = 100;


struct Heap
{
    int *heap;
    int size;
};


//初始化堆
void initHeap(Heap* pHeap);
//销毁堆
void destroyHeap(Heap* pHeap);
//在堆heap中插入data
void insertHeap(Heap* pHeap, int data);
//获得最大值
int getMax(Heap* pHeap);
//从堆中删除最大值
void deleteMax(Heap* pHeap);


int main()
{
    int buf[8] = {16, 21, 12, 30, 13, 15, 10, 25};
    Heap myHeap;
    initHeap(&myHeap);
    for (int i = 0; i < 8; i++)
    {
        insertHeap(&myHeap, buf[i]);
    }
    while (myHeap.size > 0)
    {
        cout << getMax(&myHeap) << " ";
        deleteMax(&myHeap);
    }
    destroyHeap(&myHeap);
    return 0;
}


//获得最大值
int getMax(Heap* pHeap)
{
    return pHeap->heap[0];
}


//在堆heap中插入data
void insertHeap(Heap* pHeap, int data)
{//新加入的元素放在数组的最后
    int k = pHeap->size;
    pHeap->heap[k] = data;
    pHeap->size++;
    //上筛
    while (k > 0)
    {//如果没有到达根结点，继续上筛
        int parent = (k - 1) / 2;//得到父节点的下标
        if (pHeap->heap[parent] > pHeap->heap[k])
        {//如果父节点的值大于新加入元素的值，堆序性存在，退出循环
            break;
        }
        swap(pHeap->heap[parent], pHeap->heap[k]);//交换heap[parent]和heap[k]
        k = parent;
    }
}


//从堆中删除最大值
void deleteMax(Heap* pHeap)
{
    swap(pHeap->heap[0], pHeap->heap[pHeap->size - 1]);//交换堆顶和堆的最后一个元素
    --(pHeap->size);//删除堆中的最后一个元素
    //下筛
    int parent = 0;
    int left = 2 * parent + 1;
    while (left < pHeap->size)
    {//当左子树的编号在堆的下标范围之内，说明parent是叶子结点
        int k;
        int right = left + 1;
        if (right >= pHeap->size)
        {//没有右孩子
            if (pHeap->heap[parent] > pHeap->heap[left])
            {//父结点的值大于左孩子的值，堆序性存在
                break;
            }
            k = left;
            swap(pHeap->heap[parent], pHeap->heap[k]);//交换父结点和左孩子的值
        }
        else
        {//有左右孩子
            if (pHeap->heap[parent] > pHeap->heap[left] && pHeap->heap[parent] > pHeap->heap[right])
            {//父结点的值大于左右孩子的值，堆序性存在
                break;
            }
            //把父结点的值和左右孩子中最大的值交换
            k = pHeap->heap[left] > pHeap->heap[right] ? left : right;
            swap(pHeap->heap[parent], pHeap->heap[k]);
        }
        parent = k;//下一次要下筛的结点编号
        left = 2 * parent + 1;
    }
}


//初始化堆
void initHeap(Heap* pHeap)
{
    pHeap->heap = new int[maxsize];
    pHeap->size = 0;
}


//销毁堆
void destroyHeap(Heap* pHeap)
{
    delete pHeap->heap;
    pHeap->heap = NULL;
    pHeap->size = 0;

}

方法三

//一个大顶堆的例子
#include <iostream>
#include <algorithm>
using namespace std;


const int maxsize = 100;


class Heap
{
public:
    Heap();//初始化堆
    ~Heap();//销毁堆
    void insertHeap(int data);//在堆heap中插入data
    int getMax();//获得最大值
    void deleteMax();//从堆中删除最大值
public:
    int *heap;
    int size;
};


int main()
{
    int buf[8] = {16, 21, 12, 30, 13, 15, 10, 25};
    Heap myHeap;
    for (int i = 0; i < 8; i++)
    {
        myHeap.insertHeap(buf[i]);
    }
    while (myHeap.size > 0)
    {
        cout << myHeap.getMax() << " ";
        myHeap.deleteMax();
    }
    return 0;
}


//获得最大值
int Heap::getMax()
{
    return heap[0];
}


//在堆heap中插入data
void Heap::insertHeap(int data)
{//新加入的元素放在数组的最后
    int k = size;
    heap[k] = data;
    size++;
    //上筛
    while (k > 0)
    {//如果没有到达根结点，继续上筛
        int parent = (k - 1) / 2;//得到父节点的下标
        if (heap[parent] > heap[k])
        {//如果父节点的值大于新加入元素的值，堆序性存在，退出循环
            break;
        }
        swap(heap[parent], heap[k]);//交换heap[parent]和heap[k]
        k = parent;
    }
}


//从堆中删除最大值
void Heap::deleteMax()
{
    swap(heap[0], heap[size - 1]);//交换堆顶和堆的最后一个元素
    --size;//删除堆中的最后一个元素
    //下筛
    int parent = 0;
    int left = 2 * parent + 1;
    while (left < size)
    {//当左子树的编号在堆的下标范围之内，说明parent是叶子结点
        int k;
        int right = left + 1;
        if (right >= size)
        {//没有右孩子
            if (heap[parent] > heap[left])
            {//父结点的值大于左孩子的值，堆序性存在
                break;
            }
            k = left;
            swap(heap[parent], heap[k]);//交换父结点和左孩子的值
        }
        else
        {//有左右孩子
            if (heap[parent] > heap[left] && heap[parent] > heap[right])
            {//父结点的值大于左右孩子的值，堆序性存在
                break;
            }
            //把父结点的值和左右孩子中最大的值交换
            k = heap[left] > heap[right] ? left : right;
            swap(heap[parent], heap[k]);
        }
        parent = k;//下一次要下筛的结点编号
        left = 2 * parent + 1;
    }
}


//销毁堆
void destroyHeap(Heap* pHeap)
{
    delete pHeap->heap;
    pHeap->heap = NULL;
    pHeap->size = 0;
}


Heap::Heap()
{
    heap = new int[maxsize];
    size = 0;
}


Heap::~Heap()
{
    delete[] heap;
    heap = NULL;
    size = 0;

}

方法四

//一个大顶堆的例子
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <ctime>
using namespace std;


class Heap
{
public:
    Heap();//构造函数，初始化堆
    ~Heap();//析构函数，销毁堆
    void insertHeap(int data);//在堆heap中插入data
    inline int getMax();//获得最大值
    void deleteMax();//从堆中删除最大值
    inline int getSize();//定义成内联函数，以节约函数调用的时间
    void reSize();//空间不够时，重新分配空间
private:
    int *heap; //指向内存空间的指针
    int size; //堆中实际拥有的元素个数
    int capacity;//分配给heap指针的内存空间元素个数
};


int main()
{
    srand(time(NULL));//设置随机数的种子
    Heap myHeap;//定义一个 Heap 类的对象 myHeap
    for (int i = 1; i <= 25; i++)
    {//向堆中插入25个 0 ～ 99 之间的随机数,会造成2次内存的重新分配
        myHeap.insertHeap(rand() % 100);
    }
    while (myHeap.getSize() > 0)
    {
        cout << myHeap.getMax() << " ";
        myHeap.deleteMax();
    }
    return 0;
}


//构造函数
Heap::Heap()
{
    capacity = 10;//初始化时，堆中有10个元素的空间
    heap = new int[capacity];//分配内存空间
    size = 0;
}


//析构函数
Heap::~Heap()
{
    delete[] heap;
    heap = NULL;
    size = 0;
}


//空间不够时，重新分配空间
void Heap::reSize()
{
    capacity *= 2;//空间增大2倍
    int *temp = heap;
    heap = new int[capacity];//重新申请空间
    for (int i = 0; i < size; i++)
    {//复制原内存空间中的元素到新空间
        heap[i] = temp[i];
    }
    delete[] temp;//释放原内存空间
}


inline int Heap::getSize()
{
    return size;
}


//获得最大值
int Heap::getMax()
{
    return heap[0];
}


//在堆heap中插入data
void Heap::insertHeap(int data)
{//新加入的元素放在数组的最后
    if (size + 1 > capacity)
    {//如果空间已满，则重新分配空间
        reSize();
    }
    int k = size;
    heap[k] = data;
    size++;
    //上筛
    while (k > 0)
    {//如果没有到达根结点，继续上筛
        int parent = (k - 1) / 2;//得到父节点的下标
        if (heap[parent] > heap[k])
        {//如果父节点的值大于新加入元素的值，堆序性存在，退出循环
            break;
        }
        swap(heap[parent], heap[k]);//交换heap[parent]和heap[k]
        k = parent;
    }
}


//从堆中删除最大值
void Heap::deleteMax()
{
    swap(heap[0], heap[size - 1]);//交换堆顶和堆的最后一个元素
    --size;//删除堆中的最后一个元素
    //下筛
    int parent = 0;
    int left = 2 * parent + 1;
    while (left < size)
    {//当左子树的编号在堆的下标范围之内，说明parent是叶子结点
        int k;
        int right = left + 1;
        if (right >= size)
        {//没有右孩子
            if (heap[parent] > heap[left])
            {//父结点的值大于左孩子的值，堆序性存在
                break;
            }
            k = left;
            swap(heap[parent], heap[k]);//交换父结点和左孩子的值
        }
        else
        {//有左右孩子
            if (heap[parent] > heap[left] && heap[parent] > heap[right])
            {//父结点的值大于左右孩子的值，堆序性存在
                break;
            }
            //把父结点的值和左右孩子中最大的值交换
            k = heap[left] > heap[right] ? left : right;
            swap(heap[parent], heap[k]);
        }
        parent = k;//下一次要下筛的结点编号
        left = 2 * parent + 1;
    }
}


java小菜鸟i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
堆排序详细图解（通俗易懂）
oorik的博客
02-17 21万+
什么是堆 堆是一种叫做完全二叉树的数据结构，可以分为大根堆，小根堆，而堆排序就是基于这种结构而产生的一种程序算法。 堆的分类 大根堆:每个节点的值都大于或者等于他的左右孩子节点的值 小根堆:每个结点的值都小于或等于其左孩子和右孩子结点的值 两种结构映射到数组为: 大根堆: 小根堆: //父-->子:i--->左孩子:2*i+1, 右孩子:2*i+2; //子-->父:i--->(i-1)*2;(i为下标元素) 排序思想 1.首先将待排序的数...
六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
热门推荐
HanMeng的博客
07-24 56万+
文章目录：1. 插入排序2.希尔排序 1. 插入排序 步骤： 1.从第一个元素开始，该元素可以认为已经被排序 2.取下一个元素tem，从已排序的元素序列从后往前扫描 3.如果该元素大于tem，则将该元素移到下一位 4.重复步骤3，直到找到已排序元素中小于等于tem的元素 5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置 6.重复步骤2~5 动图演示如下： 思路：   在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个
堆排序算法（图解详细流程）
阿顾的博客
08-04 22万+
堆排序的时间复杂度O(N*logN),额外空间复杂度O(1)，是一个不稳定性的排序 目录 一 准备知识 1.1 大根堆和小根堆 二 堆排序基本步骤 2.1 构造堆 2.2固定最大值再构造堆 三 总结 四代码 一 准备知识 堆的结构可以分为大根堆和小根堆，是一个完全二叉树，而堆排序是根据堆的这种数据结构设计的一种排序，下面先来看看什么是大根堆和小根堆 1.1 大根...
排序算法：堆排序
Yikefore的博客
05-28 2559
关于排序算法中的堆排序的详细介绍，以及实现过程和时间复杂度的计算，附带图解。
堆排序详解
云杉木屋
03-06 7898
摘要：堆排序是一种效率非常高的排序算法，同时它的理解以及书写方式都是比较复杂的，以至于很多企业在进行面试的时候都喜欢考察堆排序的书写速度，而堆排序在项目应用中也是有着广泛的天地，因为它的高效率，使得很多数据统计场合都会有堆排序的身影。...
十大经典排序算法详解(三)-堆排序,计数排序,桶排序,基数排序
lovely__RR的博客
02-02 4万+
十大经典排序算法-堆排序,计数排序,桶排序,基数排序 1-堆排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 2-计数排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 3-桶排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: 4-基数排序 算法思想: 算法图解: 示例代码: 在这里插入代码片 复杂度分析: ...
堆排序是什么？
Free雅轩的博客
02-23 4109
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法： 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列； 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列； 堆排序的平均时间复杂度为 Ο(nlogn)。 1. 算法步骤 创建一个堆 H[0……n-1]； 把堆首（
堆排序算法
qq_70210511的博客
08-20 6001
堆是一种数据结构，一种叫做完全二叉树的数据结构
Java堆排序
zt的博客
02-06 6774
堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。 大顶堆：每个结点的值都大于或等于左右子结点的值 小顶堆：每个结点的值都小于或等于左右子结点的值 堆排序 堆排序（英语:Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。 思路分析 1、将待排序的序列构造成一个大顶堆（升序大顶堆降
图解堆排序
12-21
在学习堆排序前，我们需要知道顺序存储二叉树和堆的知识点。 一、顺序存储二叉树 1.概念：顺序存储二叉树即用数组的方式存储二叉树的节点 2.顺序存储二叉树的特点: ①顺序二叉树通常只考虑完全二叉树 ②第n个元素的...
堆排序（C语言实现）
01-07
堆排序（C语言实现）算法思想步骤程序 算法思想 见： 4. 选择排序—堆排序（Heap Sort） 算法导论——堆排序heapsort 步骤 1. 将n个元素建立初始堆，第一个节点放在数组下标1中，因此n个节点对应数组 a[1] ~ a[n]，...
C++实现堆排序
08-25
1、 实现堆排序算法。 2、 理论分析并实验验证堆排序算法的时间复杂度。
堆排序代码
02-07
内部排序之堆排序的具体代码实现，简单同时也易于看懂
rockyou.txt
06-06
rockyou
ASP+ACCESS网上人才信息管理系统(源代码+论文)【ASP】.zip
06-06
ASP+ACCESS网上人才信息管理系统(源代码+论文)【ASP】
河北金融学院经济大数据课设2024年 软科学校爬虫课设
06-06
河北金融学院经济大数据课设2024年 软科学校爬虫课设
widgetsnbextension-4.0.0b0-py3-none-any.whl
最新发布
06-06
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值