首页 > 其他 > 详细

STL之heap相关操作算法

时间:2014-06-27 08:42:22      阅读:463      评论:0      收藏:0      [点我收藏+]

说明:本文仅供学习交流,转载请标明出处,欢迎转载!

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

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

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

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

bubuko.com,布布扣

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

  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.     }  

       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;
}

             测试结果如下:

bubuko.com,布布扣

参考资料:

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

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

STL之heap相关操作算法,布布扣,bubuko.com

STL之heap相关操作算法

原文:http://blog.csdn.net/jxh_123/article/details/34853099

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!