最大堆
应用场景：
之前学习的O(nlgn)级别的排序算法在面对动态维护的数据或者是只选出top n个元素这样的问题时并不是最优解，它们的效率在极端情况下又回到了O(n^2)级别，在这种情况下使用堆排序更为合适。
概念
数据结构上，最大堆是一种特殊的完全二叉树（父节点的值一定大于子节点，也叫最大完全二叉树），在本算法实现中将二叉树从上至下从左至右进行编号（索引从1开始，为了方便计算叶子节点索引值），根据编号顺序将元素值存入数组。
算法实现如下，关键点在于二叉树节点索引值的维护和最大堆特性的维护
#pragma once
#include <cassert>
#include "SortTestHelper.h"
/************************************************************************/
/* 最大堆：实际上是最大完全二叉树(父节点数值大于子节点的完全二叉树)，以从上到下、从左到右的顺序将节点数值存储在数组中
/************************************************************************/
using namespace std;
template<class Item>
class MaxHeap
{
public:
MaxHeap(int capacity)
{
data = new Item[capacity+1]; //数据从[1]位置处开始存储，这样使得父节点索引为其叶子节点索引除以二向下取整
this->capacity = capacity;
count = 0;
}
/*在随机的完全二叉树中，叶子节点本身就是有序的（因为没有子节点，最大堆的要求是父节点大于子节点），
只需要对所有的非叶子节点倒序执行shiftDown操作*/
MaxHeap(Item arr[],int size)
{
data = new Item[size+1]; //数据从[1]位置处开始存储，这样使得父节点索引为其叶子节点索引除以二向下取整
this->capacity = size;
for(int i=0;i<size;i++)
data[i+1] = arr[i];
count = size;
for(int i=count/2;i>=1;i-- )//完全二叉树中，最后一个非叶子节点的索引为count/2
shiftDown(i);
}
~MaxHeap(void)
{
delete data;
data = nullptr;
}
int size()
{
return count;
}
///插入元素
void insert(Item item)
{
assert(capacity>=count+1);
data[count+1] = item;
count++;
shiftUp(count);
}
///移除最大元素即根节点
Item extractMax()
{
Item item = data[1];
swap(data[1],data[count]); //保证了还是完全二叉树
count--; //注意count--与执行shiftDown的先后次序
shiftDown(1);
return item;
}
///打印输出
void printData()
{
cout<<"[";
for(int i=1;i<=count;i++)
{
if(i==count)
cout<<data[i];
else
cout<<data[i]<<",";
}
cout<<"]"<<endl;
}
private:
///将节点元素向上与父节点对比，移动到二叉树中的合适位置
void shiftUp(int k)
{
while(k>1&&data[k/2]<data[k]) ///叶子节点的父节点索引是k/2
{
swap(data[k/2],data[k]);
k/=2;
}
}
///将节点元素向下与子节点对比，移动到二叉树中的合适位置
void shiftDown(int k)
{
while(count>=k*2) //当前节点有子节点
{
int j = 2*k; //与下层节点进行比较的索引值
if(data[j+1]>data[j] && j+1<=count)
{
j++; //子节点中较大值的索引
}
if(data[k]>=data[j])
break;
swap(data[k],data[j]);
k=j;
}
}
///判空
bool isEmpty()
{
return count==0;
}
private:
///存储数据数组
Item* data;
///数据个数
int count;
///数组容量
int capacity;
};
最大索引堆：
当数据元素结构比较复杂时（比如字符串）或者在构建完堆后难以索引到某一元素的场景中（比如：优先队列），直接操作数据本身将会非常耗时，因此引入索引堆。与最大堆相似，只不过索引堆不再交换数组元素位置，而是直接使用元素的索引构建最大堆，将索引存在一个新的数组中。
索引数组的加入避免了直接操作数据本身，但是又带来了新的问题：如果想要通过原数据数组中的索引操作数据，还需要取到对应堆中的索引，又要多一层循环（即遍历索引数组，找到indexes[i] = k），这样使得算法效率大幅降低。为了解决该问题，我们使用反向查找的思想，再加入一个索引数组的反向数组reverse，使得reverse[ index [ i ] ] = i，每次操作增加reverse数组的维护，这样在通过原数据数组索引进行查找数据时，通过reverse[k]可直接获得堆中的索引。
#pragma once
#include <cassert>
#include "SortTestHelper.h"
/************************************************************************/
/* 最大索引堆：在最大堆的基础上，如果数组中储存的元素结构非常复杂（比如字符串），那么进行数据元素操作时需要消耗非常多的系统资源，
因此引入最大索引堆，使用索引数组来记录数组元素在二叉树中的位置，而真正的数据元素并不发生改变。
/************************************************************************/
using namespace std;
template<class Item>
class MaxIndexHeap
{
public:
MaxIndexHeap(int capacity)
{
data = new Item[capacity+1]; //数据从[1]位置处开始存储，这样使得父节点索引为其叶子节点索引除以二向下取整
indexes = new int[capacity+1];
reverse = new int[capacity+1]; //赋初值，因为数据元素的索引是从1开始的，所以reverse[i]=0表示当前索引不存在
for(int i=0;i<=capacity;i++)
reverse[i] = 0;
this->capacity = capacity;
count = 0;
}
/*在随机的完全二叉树中，叶子节点本身就是有序的（因为没有子节点，最大堆的要求是父节点大于子节点），
只需要对所有的非叶子节点倒序执行shiftDown操作*/
MaxIndexHeap(Item arr[],int size)
{
data = new Item[size+1]; //数据从[1]位置处开始存储，这样使得父节点索引为其叶子节点索引除以二向下取整
indexes = new int[size+1];
reverse = new int[size+1]; //赋初值，因为数据元素的索引是从1开始的，所以reverse[i]=0表示当前索引不存在
for(int i=0;i<=size;i++)
reverse[i] = 0;
this->capacity = size;
for(int i=0;i<=size;i++)
{
data[i+1] = arr[i];
indexes[i+1] = i+1;
}
count = size;
//SortTestHelper::printArr(data,11);
//SortTestHelper::printArr(indexes,11);
//SortTestHelper::printArr(reverse,11);
for(int i=count/2;i>=1;i-- )//完全二叉树中，最后一个非叶子节点的索引为count/2
{
shiftDown(i);
}
}
~MaxIndexHeap(void)
{
if(data)
{
delete[] data;
data = nullptr;
}
if(indexes)
{
delete[] indexes;
indexes = nullptr;
}
if(reverse)
{
delete[] reverse;
reverse = nullptr;
}
}
int size()
{
return count;
}
///插入元素
void insert(int index,Item item)
{
assert(capacity>=count+1);
assert(index<=capacity-1 && index>0);
index+=1; //对用户而言，索引还是从0开始的，向用户隐藏实现的细节(实际上数据是从索引1开始存储的)
data[index] = item;
indexes[count+1] = index;
reverse[index] = count+1;
count++;
shiftUp(count);
}
///移除最大元素即根节点
Item extractMax()
{
Item item = data[indexes[1]];
swap(indexes[1],indexes[count]); //保证了还是完全二叉树
count--; //注意count--与执行shiftDown的先后次序
shiftDown(1);
return item;
}
///从最大索引堆中取出堆顶元素索引
int extractMaxIndex()
{
assert(count>0);
int ret = indexes[1]-1;
swap(indexes[1],indexes[count]);
count--;
shiftDown(1);
return indexes[1]-1;
}
///获取最大索引堆的堆顶元素
Item getMax()
{
assert(count>0);
return data[indexes[1]];
}
///获取最大索引堆中的堆顶元素的索引
int getMaxIndex()
{
assert(count>0);
return indexes[1]-1;
}
///获取最大索引堆中索引为i的元素
Item getItem(int i)
{
assert(i+1>=1 && i+1<=capacity);
return data[i];
}
// 将最大索引堆中索引为i的元素修改为newItem
void change( int i , Item newItem )
{
i += 1;
data[i] = newItem;
// 找到indexes[j] = i, j表示data[i]在堆中的位置
// 之后shiftUp(j), 再shiftDown(j)
//for( int j = 1 ; j <= count ; j ++ )
//{
// if( indexes[j] == i )
// {
// shiftUp(j);
// shiftDown(j);
// return;
// }
//}
//使用反向数组进行优化
shiftUp(reverse[i]);
shiftDown(reverse[i])
}
///打印输出数据数组
void printData()
{
cout<<"data: [";
for(int i=0;i<=count;i++)
{
if(i==count)
cout<<data[i];
else
cout<<data[i]<<",";
}
cout<<"]"<<endl;
}
///打印输出索引数组
void printIndex()
{
cout<<"indexes: [";
for(int i=0;i<=count;i++)
{
if(i==count)
cout<<indexes[i];
else
cout<<indexes[i]<<",";
}
cout<<"]"<<endl;
}
///打印输出反向索引数组
void printReverseIndexArr()
{
cout<<"reverses: [";
for(int i=0;i<=count;i++)
{
if(i==count)
cout<<reverse[i];
else
cout<<reverse[i]<<",";
}
cout<<"]"<<endl;
}
private:
///将插入的叶子节点移动到最大完全二叉树的合适位置中
void shiftUp(int k)
{
while(k>1&&data[indexes[k/2]]<data[indexes[k]]) ///叶子节点的父节点索引是k/2
{
swap(indexes[k/2],indexes[k]);
reverse[indexes[k/2]]=k/2;
reverse[indexes[k]]=k;
k/=2;
}
std::cout<<"***";
SortTestHelper::printArr(reverse,11);
}
///将节点元素向下与子节点对比，移动到二叉树中的合适位置
void shiftDown(int k)
{
while(count>=k*2) //当前节点有子节点(第一个叶子节点的索引值为count/2+1)
{
int j = 2*k; //与下层节点进行比较的索引值
if(j+1<=count && data[indexes[j+1]]>data[indexes[j]])
{
j++; //子节点中较大值的索引
}
if(data[indexes[k]]>=data[indexes[j]])
break;
swap(indexes[k],indexes[j]);
reverse[indexes[k]] = k;
reverse[indexes[j]] = j;
k=j;
}
}
///判空
bool isEmpty()
{
return count==0;
}
private:
///存储数据数组
Item* data;
///索引数组
int* indexes; //indexes[i]表示数据元素的索引,i表示最大二叉树中的索引
///反向索引数组(为了提高检索的算法效率)
int* reverse; // reverse[i]表示索引数组索引，i表示索引数组元素
///数据个数
int count;
///数组容量
int capacity;
};
总结
通过引入索引数组和反向数组，堆排序的效率虽然略低于快速排序，但在处理从N个元素中选取出top M个元素的问题时，他的效率是O(NlogM)级别的，且在处理优先队列类似问题时非常有用。
89
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
