Heap-008-MaxHeap、MinHeap、IndexMaxHeap、IndexMinHeap

最新推荐文章于 2021-07-11 19:08:35 发布
最新推荐文章于 2021-07-11 19:08:35 发布
阅读量185 收藏
点赞数
分类专栏： 数据结构与算法

MaxHeap.h

#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


MinHeap.h

#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



IndexMaxHeap.h

#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



IndexMinHeap.h

#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



main.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;
}
With__Sunshine
关注
专栏目录
JavaScript:实现MaxHeap最大堆算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-13 201
JavaScript:实现MaxHeap最大堆算法（附完整源码）
PriorityQueue里面的的minheap和maxheap
DieHorseSpecial的博客
08-30 3758
static class PQsort implements Comparator<Integer> { public int compare(Integer one, Integer two) { return two - one;//或者返回负数 如-1 } }//这个是max heap的代码假设有数组 int[] ia = { 1,
Index Heap（索引堆）
秋人别院
08-25 550
数据和索引分开存储，其核心思想在于，shiftUp与shiftDown操作时，数据比较是比较的数据部分，做数据交换时则只是交换了索引。#include <iostream> #include <cassert> #include "SortTestHelper.h"using namespace std;// 最大索引堆 template<typename Item> class IndexMaxH
索引堆 Index Heap
底层码农
11-03 6193
索引堆
heap（max-heap最大堆、min-heap最小堆）
热门推荐
Damage
08-16 2万+
参考： 《STL源码剖析》   heap概述 heap并不归属于STL容器组件，它是个幕后英雄，扮演priority_queue的助手（底层实现）。所谓binary heap就是一种完全二叉树，也就是说，整颗binary tree除了最底层的叶子节点之外，是填满的，而最底层的叶节点由左至右又不得有空隙。 完全二叉树整棵树内没有任何节点漏洞，这带来一个好处：我们可以利用array来存储所...
最大堆（MaxHeap）
Cdreamfly的博客
07-11 2739
性质 二叉堆是一颗完全二叉树，而完全二叉树是把元素排列成树的形状。 堆中某个节点的值总不大于其父节点的值最大堆（相应的可以定于最小堆） // 返回完全二叉树的数组表示中，一个索引所表示的元素的父亲节点的索引 constexpr int parent(const int index) const { if (index == 0) { throw new NoParent(); } return (index - 1) / 2; } // 返回完全二叉树的数组表
数据结构：答应我，别再逃避我了好吗？
peng_zhanxuan的技术博客
05-01 726
本文我们来介绍一下编程中常见的一些数据结构。 为什么要学习数据结构？ 随着业务场景越来越复杂，系统并发量越来也高，要处理的数据越来越多，特别是大型互联网的高并发、高性能、高可用系统，对技术要求越来越高，我们引入各种中间件，这些中间件底层涉及到的各种数据结构和算法，是其核心技术之一。如： ElasticSearch中用于压缩倒排索引内存存储空间的FST，用于查询条件合并的SkipList，用于提高...
maxheap-algorithm
06-26
算法 这些包含以线性时间复杂度构建堆的 maxheap 和 minheap java 代码。 我们可以在堆上执行删除和插入功能。
heap:Java中的MinMax堆和堆排序实现
05-03
const { MinHeap , MaxHeap } = require ( '@datastructures-js/heap' ) ; 进口 import { MinHeap , MaxHeap } from '@datastructures-js/heap' ; 原料药 新的 创建一个空堆。 const minHeap = new MinHeap
最大堆MaxHeap和最小堆MinHeap的实现
xwdreamer的专栏
12-04 1万+
       优先队列式分支界限法解装载问题中需要用到最大堆MazHeap，但是书上没有给出代码，所以只能我们自己写了，下面我贴出这两个数据结构的代码，以供参考。解决了这两个数据结构，那么优先队列式分支界限法就很好实现了。最大堆MaxHeap：#includeusing namespace std;typedef struct Heap{ int capacity; i
数据结构之最大堆（MaxHeap）源代码
数据结构学习心得
04-02 1408
MaxHeap.h文件#pragma once #include&lt;iostream&gt; using namespace std; //enum bool{true, false}; #define defaultSize 100 template&lt;class T&gt; class MaxHeap { public: MaxHeap(int sz = defaultSize); ...
最大堆MaxHeap源码
游戏猫的博客
12-23 583
最大堆MaxHeap源码MaxHeap.h源码#pragma once #include "stdafx.h" #include <vector> using namespace std; class MaxHeapNode { private: int _nodeIndex; float _nodeValue; public: MaxHeapNode(float node
最大堆(max-heap)和最小堆(min-heap)
Tim's Blog
11-15 8534
在STL中，二叉堆是通过priority_queue的类模板实现的，标准头文件是。在STL中实现的是最大堆(max-heap)。 成员函数有： void push (const Object & x); const Object & top() const; void pop(); bool empty(); void clear(); 优先队列模版用如下参数初始化：项类型，容器类型（几乎总
MaxHeap & MinHeap 简单易懂的介绍
01-13 1070
看面经的时候看到了特么要手动实现最大堆和最小堆。我就赶紧上网搜了搜，发现这篇特别好。这里转载一下：http://www.cnblogs.com/skywang12345/p/3610187.html 以最大堆为例，最大堆的特点为 [性质一] 堆中任意节点的值总是不小于其子节点的值； [性质二] 堆总是一棵完全树。 下面是例子，因为是完全树，所以堆完全可以由数组来表示 (01) 索引为i的
山东交通学院在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
西京学院在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
山西师范大学在江西2020-2024各专业最低录取分数及位次表.pdf
最新发布
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
沈阳工业大学在江西2020-2024各专业最低录取分数及位次表.pdf
10-02
那些年，与你同分同位次的同学都去了哪里？全国各大学在江西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
基于Arduino平台的自动寻找物品设计源码
10-02
该项目是一款基于Arduino平台的自动寻找物品设计源码，包含302个文件，包括148个头文件、136个C语言源文件、3个Markdown文件、3个JSON文件、3个包含文件、2个C语言扩展文件、2个压缩文件、2个汇编文件、1个Git忽略文件、1个Arduino源代码文件。该系统旨在实现物品的自动定位和寻找。
7-2 堆中的路径c语言
05-13
void insert_heap(MinHeap *heap, int value) { if (heap->size >= MAX_HEAP_SIZE) { printf("Heap is full, cannot insert %d\n", value); return; } int index = heap->size; heap->data[index] = value; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值