STL之heap相关操作算法

说明：本文仅供学习交流，转载请标明出处，欢迎转载！

       堆（heap）是一种非常重要的数据结构（这里我们讨论的是二叉堆），它是一棵满足特定条件的完全二叉树，堆的定义如下：

       堆是一棵树完全二叉树，对于该完全二叉树中的每一个结点x，其关键字大于等于(或小于等于）其左右孩子结点，而其左右子树均为一个二叉堆。

        在上述的定义中，若堆中父亲结点关键字的值大于等于孩子结点，则称该堆为大顶堆；若堆中父亲结点关键子的值小于等于孩子结点，则称该堆为小顶堆。

        由于堆是一棵完全二叉树，所以我们可以很轻易地用一个数组存储堆中的每一个元素，并且由子结点访问到其父亲结点和由父亲结点访问到其子结点。下面给出图来说明该表示方法：

          下面我们给出学数据结构时堆数组进行堆排序的整个过程：建堆、出堆、向上调整、向下调整等过程。

1. 堆排序(大顶堆)//  
2. ///堆是一个完全二叉树，若结点索引从0开始，则i结点的左孩子为2*i+1,右为2*i+2  
3. void HeapAdjustDown(int *arr,int length,int i)//对第i个值做向下调整，i=0,...,length-1  
4. {  
5.     if(arr==NULL || length<=0 || i<0)  
6.     {  
7.         return ;  
8.     }  
9.     int temp=arr[i];  
10.     int j;//i相当于前驱，j相当于后继  
11.     for(j=2*i+1;j<length;)//即j<=length-1  
12.     {  
13.         if(j+1<length && arr[j]<arr[j+1])//如果存在右孩子，且右孩子值待遇  
14.         {  
15.             j++;//与右孩子交换  
16.         }  
17.         if(arr[j]<=temp)//如果左右孩子中的较大值小于该结点值，则说明无需向下调整了  
18.         {  
19.             break;  
20.         }  
21.         else//如果左右孩子中的较大值大于该结点值，则想到直接插入排序  
22.         {  
23.             arr[i]=arr[j];//孩子结点值中较大的上移动  
24.             i=j;//i用于追踪待插入点的位置  
25.             j=2*i+1;  
26.         }  
27.     }  
28.     if(arr[i]!=temp)//如果i的值发生了移动  
29.     {  
30.         arr[i]=temp;//将最初第i个节点值放入合适的位置  
31.     }  
32.   
33. }  
34. void CreateHeap(int *arr,int length)//创建一个堆  
35. {  
36.     if(arr==NULL || length<=0)  
37.     {  
38.         return ;  
39.     }  
40.     int i;  
41.     for(i=(length-2)/2;i>=0;i--)//最后一个元素的序号为length-1,故该结点的父结点为(length-2)/2  
42.     {  
43.         HeapAdjustDown(arr,length,i);//从倒数第二行开始倒着向下调整  
44.     }  
45. }  
46. void HeapDelete(int *arr,int len)//删堆顶元素，len表示当前表的长度  
47. {  
48.     if(arr==NULL || len<=0 || len==1)//len=1,表示当堆中只有一个元素时，无需排序  
49.     {  
50.         return ;  
51.     }  
52.     else  
53.     {  
54.         swap(arr[0],arr[len-1]);  
55.         HeapAdjustDown(arr,len-1,0);//删除后，数组长度减1了  
56.     }  
57. }  
58.   
59. void HeapSort(int *arr,int length)//堆排序  
60. {  
61.     if(arr==NULL || length<=1)  
62.     {  
63.         return ;  
64.     }  
65.     CreateHeap(arr,length);//先创建一个堆0  
66.     int i;  
67.     for(i=0;i<=length-1;i++)//删除length-1次即可，因为最后一个元素就剩自己了  
68.     {  
69.         HeapDelete(arr,length-i);  
70.     }  
71. } 

       STL的魅力之一在于能够对特定类型的数据结构提供泛型化，并且提供高效的函数接口。没错，STL不仅实现了上述算法，而且还弥补上述算法的不足。

        从上面的代码中，我们发现的不足之处在于：整个过程都是针对一个静态数组，静态数组在插入和删除方面表现的特别笨。所以，STL以动态数组vector为底层实现，提供了几个重要的关于堆的几个重要操作，这些操作分别是：建堆操作、插入操作、删除操作、堆排序操作，下面分别给出这几种操作的函数原型和相关说明。

建堆算法：inline void make_heap( b, e , cmp=greater<T>() )

        该函数对[b,e)范围中的元素建立一个堆，所建的堆的类型由cmp决定，默认为大顶堆。

堆插入算法：inline void push_heap(b,e,cmp=greater<T>() )

        向堆中插入元素分为两个步骤：

       （1）先将待插入的元素插入到底层容器的末端，通过push_back函数实现。

       （2）再调用push_heap(b,e,cmp)函数堆新插入的元素做向上调整。

         所以，调用push_heap函数之前，先要保证待插入的元素已经放到了原容器的末尾，否则push_heap就做了无用功。

堆假删除算法：inline void pop_heap(b,e,cmp=greater<T>() )

        要实现堆的真正删除操作，分两步进行：

      （1）先调用pop_heap函数将首部的元素与尾部元素交换，再将原尾部的元素做向下调整操作。此时，原堆顶元素被放置在最后一个位置，并未从底层容器中删除。

      （2）若要实现真正的元素删除，可以调用底层容器的pop_back函数。

        所以，在调用pop_heap函数后，若要实现元素真正从堆中删除，还需要调用底层容器的pop_back函数。

堆排序算法：inline void sort_heap(b,e,cmp=greater<T>() )

       根据上面的堆排序代码，我们可以看出，堆排序实际上是对堆中元素不断地假删除操作，只不过在删除过程中，[b,e)中的e每删除一次，就要做--e的更新。

        总结，以上的几个函数中，都要注意以下几个问题：

        1.所以的[b,e)中的b和e都是随机访问迭代器(RandomAccessIterator)，根据这一性质，我们可以得出，在我们之前提过的三个基础顺序容器中，只有vector和deque可以作为堆的底层实现容器，而list容器不能作为底层实现容器，因为list容器内置的迭代器为随机访问迭代器。

        2.上述函数都含有第三个参数，该参数决定了堆的类型（大顶堆、小顶堆），默认情况下，该堆的类型为大顶堆。如果我们要使用小顶堆，则之后所有的以上函数的调用都必须加上对应的参数，否则结果就会出错。

        3.以上函数的第三个参数，我们有两种给出实参的方法：

      （1）采用仿函数对象,这是C++的习惯，对应的头文件为:#include<functional>。注意是仿函数对象，不是仿函数类型，对象只出现在函数内部，类型则只出现在模板内部，仿函数都是inline函数，所以其效率要高于(2)。

        例如： 小顶堆------->greater<T>()     大顶堆------------------>less<T>()

      （2）采用自定义函数名，并将该函数名传递给第三个参数，具体如下：

bool less_cmp(const int &a,const int &b)//等价于: less<int>()
{
	return a<b;
}

bool greater_cmp(const int &a, const int &b) //等价于: greater<int>()
{
	return a>b;
}

            最后，我们给出一个小顶堆的测试程序及其输出结果：

#include<iostream>
#include<vector>
#include<list>
#include<algorithm>//后面用到copy函数和heap相关函数
#include<iterator>//后面用到迭代器ostream_iterator
#include<functional>//后面用到了一个比较的仿函数greater<T>
using namespace std;
typedef vector<int> Vint;
void print(const Vint& vec)//输出当前vector容器中的元素
{
	cout<<"容器内的元素为:";
	copy(vec.begin(),vec.end(),ostream_iterator<int>(cout," "));//将容器内的元素输出到标准输出设备上
	cout<<endl;
	cout<<"容器内元素的个数为:"<<vec.size()<<endl<<endl;;
}

bool cmp(const int &a,const int &b)
{
	return a>b;//大顶堆，则cmp相等于greater<int>(),注意不是greater<int>，前者是一个对象，后者是一个类
}
int main()
{
	int arr[]={3,2,1,9,4,12,15,7};
	vector<int>vec(arr,arr+sizeof(arr)/sizeof(int));//创建一个vector容器对象，将数组的副本压入到该容器中
	cout<<"-----------初始状态---------------"<<endl;
	print(vec);//将最初的vector容器的内容输出

	cout<<"-------------建堆----------------"<<endl;
	make_heap(vec.begin(),vec.end(),cmp);//新建一个小顶堆
	//上行代码等价于make_heap(vec.begin(),vec.end(),greater<int>()
	print(vec);
	
	cout<<"----------弹出堆顶元素-----------"<<endl;
	pop_heap(vec.begin(),vec.end(),cmp);//这里也要加cmp，因为弹出之后要给出向下调整的规则，否则系统会调用默认的最大堆调整方法
	print(vec);

	cout<<"--------向堆中插入值6的方法--------"<<endl;
	vec.push_back(6);//先将待插入的值放在容器的末尾
	push_heap(vec.begin(),vec.end(),cmp);//再最堆进行向下调整
	print(vec);

	cout<<"----------执行堆排序--------------"<<endl;
	sort_heap(vec.begin(),vec.end(),cmp);
	print(vec);
	return 0;
}

             测试结果如下：

参考资料：

[1]《STL源码剖析 侯捷》

[2]《C++ primer 第4版》