和堆相关的问题

最新推荐文章于 2023-09-20 18:03:18 发布
最新推荐文章于 2023-09-20 18:03:18 发布
阅读量93 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43579079/article/details/101779322
版权

使用堆实现优先队列

动态选择优先级最高的任务实行；既可以修改优先级别也可以加入新的任务。
也可以在N个元素中选出前M个元素，使用优先队列N l o g M log_M logM​

多路归并排序

归并时每次比较多部分的元素，将这些元素放入堆中，然后直接选出优先级最高的元素，选出后继续补充新的元素；极端情况是一个元素是一部分，归并排序退化成了堆排序；取几部分是一个超参数。

二叉堆到d-叉堆

每个父节点要有d个子节点。d是一个超参数，一般2可以解决大部分问题。

堆的实现细节优化

shiftup和shiftdown中使用赋值操作代替swap操作；
表示堆的操作从0开始；
没有capacity的限制，动态的调整堆中数组的大小（原来是固定的大小）

最大最小队列

最大堆和最小堆同时维护同一组数据，同时获得最大和最小值。

mian.cpp

#include <iostream>
#include "MaxHeap.h"
#include "MinHeap.h"
#include "IndexMaxHeap.h"
#include "IndexMinHeap.h"
#include "SortTestHelper.h"

using namespace std;

template<typename T>
void heapSortUsingMaxHeap(T arr[], int n){

    MaxHeap<T> maxheap = MaxHeap<T>(n);
    for( int i = 0 ; i < n ; i ++ )
        maxheap.insert(arr[i]);

    for( int i = n-1 ; i >= 0 ; i-- )
        arr[i] = maxheap.extractMax();

}

template<typename T>
void heapSortUsingIndexMaxHeap(T arr[], int n){

    IndexMaxHeap<T> indexMaxheap = IndexMaxHeap<T>(n);
    for( int i = 0 ; i < n ; i ++ )
        indexMaxheap.insert(i, arr[i]);

    for( int i = n-1 ; i >= 0 ; i-- )
        arr[i] = indexMaxheap.extractMax();

}

template<typename T>
void heapSortUsingMinHeap(T arr[], int n){

    MinHeap<T> minheap = MinHeap<T>(n);
    for( int i = 0 ; i < n ; i ++ )
        minheap.insert(arr[i]);

    for( int i = 0 ; i < n ; i++ )
        arr[i] = minheap.extractMin();

}

template<typename T>
void heapSortUsingIndexMinHeap(T arr[], int n){

    IndexMinHeap<T> indexMinheap = IndexMinHeap<T>(n);
    for( int i = 0 ; i < n ; i ++ )
        indexMinheap.insert(i, arr[i]);

    for( int i = 0 ; i < n ; i++ )
        arr[i] = indexMinheap.extractMin();

}

int main() {

    int n = 1000000;

    int* arr1 = SortTestHelper::generateRandomArray(n,0,n);
    int* arr2 = SortTestHelper::copyIntArray(arr1, n);
    int* arr3 = SortTestHelper::copyIntArray(arr1, n);
    int* arr4 = SortTestHelper::copyIntArray(arr1, n);

    SortTestHelper::testSort("Heap Sort Using Max Heap", heapSortUsingMaxHeap, arr1, n);
    SortTestHelper::testSort("Heap Sort Using Index Max Heap", heapSortUsingIndexMaxHeap, arr2, n);
    SortTestHelper::testSort("Heap Sort Using Min Heap", heapSortUsingMinHeap, arr3, n);
    SortTestHelper::testSort("Heap Sort Using Index Min Heap", heapSortUsingIndexMinHeap, arr4, n);

    delete[] arr1;
    delete[] arr2;
    delete[] arr3;
    delete[] arr4;

    return 0;
}

MinHeap,h

//
// Created by liuyubobobo on 9/13/16.
//

#ifndef HEAP_MINHEAP_H
#define HEAP_MINHEAP_H

#include <algorithm>
#include <cassert>

using namespace std;


template<typename Item>
class MinHeap{

private:
    Item *data;
    int count;
    int capacity;

    void shiftUp(int k){
        while( k > 1 && data[k/2] > data[k] ){
            swap( data[k/2], data[k] );
            k /= 2;
        }
    }

    void shiftDown(int k){
        while( 2*k <= count ){
            int j = 2*k;
            if( j+1 <= count && data[j+1] < data[j] ) j ++;
            if( data[k] <= data[j] ) break;
            swap( data[k] , data[j] );
            k = j;
        }
    }

public:

    MinHeap(int capacity){
        data = new Item[capacity+1];
        count = 0;
        this->capacity = capacity;
    }

    MinHeap(Item arr[], int n){
        data = new Item[n+1];
        capacity = n;

        for( int i = 0 ; i < n ; i ++ )
            data[i+1] = arr[i];
        count = n;

        for( int i = count/2 ; i >= 1 ; i -- )
            shiftDown(i);
    }

    ~MinHeap(){
        delete[] data;
    }

    int size(){
        return count;
    }

    bool isEmpty(){
        return count == 0;
    }

    void insert(Item item){
        assert( count + 1 <= capacity );
        data[count+1] = item;
        shiftUp(count+1);
        count ++;
    }

    Item extractMin(){
        assert( count > 0 );
        Item ret = data[1];
        swap( data[1] , data[count] );
        count --;
        shiftDown(1);
        return ret;
    }

    Item getMin(){
        assert( count > 0 );
        return data[1];
    }
};

#endif //HEAP_MINHEAP_H

MaxHeap.h

//
// Created by liuyubobobo on 9/13/16.
//

#ifndef HEAP_MAXHEAP_H
#define HEAP_MAXHEAP_H

#include <algorithm>
#include <cassert>

using namespace std;


template<typename Item>
class MaxHeap{

private:
    Item *data;
    int count;
    int capacity;

    void shiftUp(int k){
        while( k > 1 && data[k/2] < data[k] ){
            swap( data[k/2], data[k] );
            k /= 2;
        }
    }

    void shiftDown(int k){
        while( 2*k <= count ){
            int j = 2*k;
            if( j+1 <= count && data[j+1] > data[j] ) j ++;
            if( data[k] >= data[j] ) break;
            swap( data[k] , data[j] );
            k = j;
        }
    }

public:

    MaxHeap(int capacity){
        data = new Item[capacity+1];
        count = 0;
        this->capacity = capacity;
    }

    MaxHeap(Item arr[], int n){
        data = new Item[n+1];
        capacity = n;

        for( int i = 0 ; i < n ; i ++ )
            data[i+1] = arr[i];
        count = n;

        for( int i = count/2 ; i >= 1 ; i -- )
            shiftDown(i);
    }

    ~MaxHeap(){
        delete[] data;
    }

    int size(){
        return count;
    }

    bool isEmpty(){
        return count == 0;
    }

    void insert(Item item){
        assert( count + 1 <= capacity );
        data[count+1] = item;
        shiftUp(count+1);
        count ++;
    }

    Item extractMax(){
        assert( count > 0 );
        Item ret = data[1];
        swap( data[1] , data[count] );
        count --;
        shiftDown(1);
        return ret;
    }

    Item getMax(){
        assert( count > 0 );
        return data[1];
    }
};

#endif //HEAP_MAXHEAP_H

IndexMinHeap.h

//
// Created by liuyubobobo on 9/13/16.
//

#ifndef HEAP_INDEXMINHEAP_H
#define HEAP_INDEXMINHEAP_H

#include <iostream>
#include <algorithm>
#include <cassert>

using namespace std;


template<typename Item>
class IndexMinHeap{

private:
    Item *data;
    int *indexes;
    int *reverse;

    int count;
    int capacity;

    void shiftUp( int k ){

        while( k > 1 && data[indexes[k/2]] > data[indexes[k]] ){
            swap( indexes[k/2] , indexes[k] );
            reverse[indexes[k/2]] = k/2;
            reverse[indexes[k]] = k;
            k /= 2;
        }
    }

    void shiftDown( int k ){

        while( 2*k <= count ){
            int j = 2*k;
            if( j + 1 <= count && data[indexes[j]] > data[indexes[j+1]] )
                j += 1;

            if( data[indexes[k]] <= data[indexes[j]] )
                break;

            swap( indexes[k] , indexes[j] );
            reverse[indexes[k]] = k;
            reverse[indexes[j]] = j;
            k = j;
        }
    }

public:
    IndexMinHeap(int capacity){

        data = new Item[capacity+1];
        indexes = new int[capacity+1];
        reverse = new int[capacity+1];

        for( int i = 0 ; i <= capacity ; i ++ )
            reverse[i] = 0;

        count = 0;
        this->capacity = capacity;
    }

    ~IndexMinHeap(){
        delete[] data;
        delete[] indexes;
        delete[] reverse;
    }

    int size(){
        return count;
    }

    bool isEmpty(){
        return count == 0;
    }

    void insert(int index, Item item){
        assert( count + 1 <= capacity );
        assert( index + 1 >= 1 && index + 1 <= capacity );

        index += 1;
        data[index] = item;
        indexes[count+1] = index;
        reverse[index] = count+1;
        count++;
        shiftUp(count);
    }

    Item extractMin(){
        assert( count > 0 );

        Item ret = data[indexes[1]];
        swap( indexes[1] , indexes[count] );
        reverse[indexes[count]] = 0;
        reverse[indexes[1]] = 1;
        count--;
        shiftDown(1);
        return ret;
    }

    int extractMinIndex(){
        assert( count > 0 );

        int ret = indexes[1] - 1;
        swap( indexes[1] , indexes[count] );
        reverse[indexes[count]] = 0;
        reverse[indexes[1]] = 1;
        count--;
        shiftDown(1);
        return ret;
    }

    Item getMin(){
        assert( count > 0 );
        return data[indexes[1]];
    }

    int getMinIndex(){
        assert( count > 0 );
        return indexes[1]-1;
    }

    bool contain( int index ){

        return reverse[index+1] != 0;
    }

    Item getItem( int index ){
        assert( contain(index) );
        return data[index+1];
    }

    void change( int index , Item newItem ){

        assert( contain(index) );
        index += 1;
        data[index] = newItem;

        shiftUp( reverse[index] );
        shiftDown( reverse[index] );
    }

};

#endif //HEAP_INDEXMINHEAP_H

IndexMaxHeap.h

//
// Created by liuyubobobo on 9/13/16.
//

#ifndef HEAP_INDEXMAXHEAP_H
#define HEAP_INDEXMAXHEAP_H

#include <iostream>
#include <algorithm>
#include <cassert>

using namespace std;


template<typename Item>
class IndexMaxHeap{

private:
    Item *data;
    int *indexes;
    int *reverse;

    int count;
    int capacity;

    void shiftUp( int k ){

        while( k > 1 && data[indexes[k/2]] < data[indexes[k]] ){
            swap( indexes[k/2] , indexes[k] );
            reverse[indexes[k/2]] = k/2;
            reverse[indexes[k]] = k;
            k /= 2;
        }
    }

    void shiftDown( int k ){

        while( 2*k <= count ){
            int j = 2*k;
            if( j + 1 <= count && data[indexes[j+1]] > data[indexes[j]] )
                j += 1;

            if( data[indexes[k]] >= data[indexes[j]] )
                break;

            swap( indexes[k] , indexes[j] );
            reverse[indexes[k]] = k;
            reverse[indexes[j]] = j;
            k = j;
        }
    }

public:
    IndexMaxHeap(int capacity){

        data = new Item[capacity+1];
        indexes = new int[capacity+1];
        reverse = new int[capacity+1];
        for( int i = 0 ; i <= capacity ; i ++ )
            reverse[i] = 0;

        count = 0;
        this->capacity = capacity;
    }

    ~IndexMaxHeap(){
        delete[] data;
        delete[] indexes;
        delete[] reverse;
    }

    int size(){
        return count;
    }

    bool isEmpty(){
        return count == 0;
    }

    // 传入的i对用户而言,是从0索引的
    void insert(int i, Item item){
        assert( count + 1 <= capacity );
        assert( i + 1 >= 1 && i + 1 <= capacity );

        i += 1;
        data[i] = item;
        indexes[count+1] = i;
        reverse[i] = count+1;
        count++;

        shiftUp(count);
    }

    Item extractMax(){
        assert( count > 0 );

        Item ret = data[indexes[1]];
        swap( indexes[1] , indexes[count] );
        reverse[indexes[count]] = 0;
        reverse[indexes[1]] = 1;
        count--;
        shiftDown(1);
        return ret;
    }

    int extractMaxIndex(){
        assert( count > 0 );

        int ret = indexes[1] - 1;
        swap( indexes[1] , indexes[count] );
        reverse[indexes[count]] = 0;
        reverse[indexes[1]] = 1;
        count--;
        shiftDown(1);
        return ret;
    }

    Item getMax(){
        assert( count > 0 );
        return data[indexes[1]];
    }

    int getMaxIndex(){
        assert( count > 0 );
        return indexes[1]-1;
    }

    bool contain( int i ){
        assert( i + 1 >= 1 && i + 1 <= capacity );
        return reverse[i+1] != 0;
    }

    Item getItem( int i ){
        assert( contain(i) );
        return data[i+1];
    }

    void change( int i , Item newItem ){

        assert( contain(i) );
        i += 1;
        data[i] = newItem;

        int j = reverse[i];
        shiftUp( j );
        shiftDown( j );
    }

};

#endif //HEAP_INDEXMAXHEAP_H

SortTestHelper.h

//
// Created by liuyubobobo on 9/13/16.
//

#ifndef HEAP_SORTTESTHELPER_H
#define HEAP_SORTTESTHELPER_H

#include <iostream>
#include <algorithm>
#include <string>
#include <ctime>
#include <cassert>
#include <string>

using namespace std;


namespace SortTestHelper {

    int *generateRandomArray(int n, int range_l, int range_r) {

        int *arr = new int[n];

        srand(time(NULL));
        for (int i = 0; i < n; i++)
            arr[i] = rand() % (range_r - range_l + 1) + range_l;
        return arr;
    }

    int *generateNearlyOrderedArray(int n, int swapTimes){

        int *arr = new int[n];
        for(int i = 0 ; i < n ; i ++ )
            arr[i] = i;

        srand(time(NULL));
        for( int i = 0 ; i < swapTimes ; i ++ ){
            int posx = rand()%n;
            int posy = rand()%n;
            swap( arr[posx] , arr[posy] );
        }

        return arr;
    }

    int *copyIntArray(int a[], int n){

        int *arr = new int[n];
        copy(a, a+n, arr);
        return arr;
    }

    template<typename T>
    void printArray(T arr[], int n) {

        for (int i = 0; i < n; i++)
            cout << arr[i] << " ";
        cout << endl;

        return;
    }

    template<typename T>
    bool isSorted(T arr[], int n) {

        for (int i = 0; i < n - 1; i++)
            if (arr[i] > arr[i + 1])
                return false;

        return true;
    }

    template<typename T>
    void testSort(const string &sortName, void (*sort)(T[], int), T arr[], int n) {

        clock_t startTime = clock();
        sort(arr, n);
        clock_t endTime = clock();
        cout << sortName << " : " << double(endTime - startTime) / CLOCKS_PER_SEC << " s"<<endl;

        assert(isSorted(arr, n));

        return;
    }

};

#endif //HEAP_SORTTESTHELPER_H
weixin_43579079
关注
专栏目录
数据结构：堆排序(升序排序建大堆)，TOP-K问题
10-06
在这个场景中，我们关注的是“堆排序”以及与之相关的“TOP-K”问题。首先，让我们深入理解这两个概念。 堆排序是一种基于比较的排序算法，它利用了数据结构中的“堆”这一特性。堆是一个近似完全二叉树的结构，...
python 堆和优先队列的使用详解
09-19
### Python堆和优先队列的使用详解 ...通过对内置类型、元组类型以及自定义类的实例演示，展示了如何有效地利用Python的堆和优先队列解决实际问题。希望读者能够掌握这些基础知识，并在实际项目中灵活运用。
堆相关问题
kinredon的博客
04-01 262
讲堆不得不提的就是优先队列。什么是优先队列？普通队列：先进先出，后进后出优先队列：出队顺序和入队顺序无关；和优先级相关如何实现优先队列？由上图可知，用堆来实现优先队列是一个理想的方法。这里采用二叉堆（最大堆）的定义：  所有节点的值都不大于其父节点的值  二叉堆是一个完全二叉树采用数组来存储二叉堆由二叉堆的定义可以得出结论：对一颗完全二叉树按层序遍历编号，根节点的编号为1, 假设父节点的编号为 i...
堆球问题，开普勒猜想（格密码相关）
forest_LL的博客
02-20 2267
堆球问题又叫堆球理论、最密堆积、球填充，英文为The Theory Of Sphere Packings。堆球问题的本质就是填充一堆大小相同的球。要求这些球是刚球，互相之间不能重叠，寻找其最大的密度。关于该密度，简单给一个解释，假设有一个边长为a的立方体的箱子，最大可以放n个体积为v的小球，那么堆球的最大密度即为：备注：很明显该处例子为三维情况，还可以是四维、五维、······（可以思考下高维下球变成？立方体变成？三维寻找最高的堆球密度又被称之为开普勒猜想。
一文读懂堆与栈的区别
热门推荐
Dablelv 的博客专栏。
06-29 40万+
堆（Heap）与栈（Stack）是开发人员必须面对的两个概念，在理解这两个概念时，需要放到具体的场景下，因为不同场景下，堆与栈代表不同的含义。一般情况下，有两层含义： （1）程序内存布局场景下，堆与栈表示的是两种程序内存分区； （2）数据结构场景下，堆与栈表示两种常用的数据结构。 1.程序内存分区——堆与栈 栈由操作系统自动分配释放 ，用于存放函数的参数值、局部变量的值等，其操作方式类......
栈和堆的区别
weixin_43123279的博客
03-19 4566
栈和堆的区别 前面已经介绍过，栈是由编译器在需要时分配的，不需要时自动清除的变量存储区。里面的变量通常是局部变量、函数参数等。堆是由malloc()函数分配的内存块，内存释放由程序员手动控制，在C语言为free函数完成。栈和堆的主要区别有以下几点： （1）管理方式不同。 栈编译器自动管理，无需程序员手工控制；而堆空间的申请释放工作由程序员控制，容易产生内存泄漏。对于栈来讲，是由编译器自动管理，无需...
Java中的堆和栈
做一个有思想的技术人
11-10 8513
栈和堆是Java程序在代码执行期间使用的两个区域。除了这两个之外，还有其他内存区域，如方法区域、寄存器、本地方法域等等。每种区域在Java应用程序中都有其特定的用途。但是，从程序员的角度来看，栈和堆是JVM必须理解的区域。
堆排序+TopK问题
2201_76062618的博客
07-18 3332
本文讲解堆排序+TopK问题，内容较为丰富
解密堆排序与TopK问题
2202_75605090的博客
09-20 1183
在二叉树的存储结构中提到堆可以进行排序，也就是今天的主题堆排序，堆的排序还可以解决Topk问题，今天我就向大家解密什么是堆排序和Topk问题，它们的原理又是什么。Top-K问题是指从一组元素中找出前K个最大（或最小）的元素。这个问题在数据处理和算法设计中经常遇到，常见的应用场景包括搜索引擎中的搜索结果排序、推荐系统中的物品推荐、数据分析中的数据筛选等。找出前K个最大的元素。
ES堆占用高问题分析与解决方案
Angus
09-25 7493
千亿级检索，ES JVM参数调优，解决OOM问题。
堆和栈的精华大总结
少说，多做。
11-18 1万+
Java内存分配原理 栈、堆、常量池虽同属Java内存分配时操作的区域，但其适用范围和功用却大不相同。 一般Java在内存分配时会涉及到以下区域： ◆寄存器：我们在程序中无法控制 ◆栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中 ◆堆：存放用new产生的数据 ◆静态域：存放在对象中用static定义的静态成员 ◆常量池：存放常量 ◆非RAM存储：硬盘...
堆的相关操作（创建堆、插入、删除、堆排序、top-k问题）
weixin_62042704的博客
12-08 3138
一、什么是堆 堆得满足两个特性：1、首先得是一个完全二叉树 2、每个节点比其孩子节点都大（小），则其是大（小）堆。 堆是将其元素存储在一维数组中的。 二、堆的创建 1、首先了解堆向下调整算法： 向下调整算法有一个前提：左右子树必须得是一个堆。如图所示，只有根节点不满足堆的特性。 现在就来向下调整根节点，使其整体成为一个小堆。具体做法是让父节点和它较小的子节点交换（前提是左右节点都存在），然后再让父节点等于子节点；重复此操作...
基于物理反应神经网络（PINN）深度机器学习技术的核反应堆中子相关问题的解决方法+源码+说明资料.zip
02-16
这个项目的目的是为了学习和理解这些方法的工作原理，以及如何将它们应用于核反应堆相关问题。我们鼓励对核能技术和深度学习感兴趣的研究人员和学生参与到这个项目中。在各个子目录中，您将找到有关每个主题的详细...
关于堆和栈的那些事共9页.pdf.zip
10-31
在实际编程中，堆和栈的运用也与特定编程语言密切相关。例如，在C++中，类的对象可以在栈上（如果大小确定且不超出栈的限制）或堆上（如果对象较大或生命周期不确定）创建。而在Java中，由于垃圾回收机制的存在，...
基于微信小程序的新生报到系统设计与实现.docx
09-13
基于微信小程序的新生报到系统设计与实现.docx
基于java的电商平台的设计与实现.docx
09-13
基于java的电商平台的设计与实现.docx
基于java的大学生智能消费记账系统的设计与实现.docx
09-13
基于java的大学生智能消费记账系统的设计与实现.docx
基于java的植物健康系统设计与实现.docx
09-13
基于java的植物健康系统设计与实现.docx
weixin151云匹面粉直供微信小程序+springboot.rar
最新发布
09-13
所有源码，都可正常运行
堆叠故障排查与案例分析：常见问题与解决策略
堆叠无法建立的情况可能由多种原因导致，包括配置错误和物理链路问题。定位流程主要包括以下几个步骤： 1. **确认设备支持堆叠**：首先，通过`displaydevice`命令检查设备型号，比如S5735-L8T4X-A1，查看其是否支持...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值