heap最大(小)堆

首先是概念，堆属于完全二叉树。

完全二叉树百度百科描述是：

（1）若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数。

（2）第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

最大堆对于完全二叉树的节点数值要求是：

根结点的键值是所有堆结点键值中最大者，且每个结点的值都比其孩子的值大。也就是说左右子树也是一个大顶堆。

堆一般通过数组表示。从上到下从左到右一个个排列。

先给个我们使用heap的例子

#include<iostream>
    #include<vector>
    #include<algorithm>
    using namespace std;
int main()
{
  vector<int> v;
  v.reserve(16);
  v.push_back(1);
  v.push_back(5);
  v.push_back(8);
  v.push_back(6);
  v.push_back(7);
  make_heap(v.begin(),v.end());       //先创建一个大顶堆再说
  for(int i = 0; i < v.size(); ++i)
  {
    cout << v[i] << " ";
  }
  cout << endl;                       //输出结果 8 7 1 6 5 最大的8到最前面去了吧~

  pop_heap(v.begin(),v.end());        //吧最大那个就是第一个弄出来，vector里的值会删除吗？？不会
  for(int i = 0; i < v.size(); ++i)
  {
    cout << v[i] << " ";
  }
  cout << endl;                      //输出结果 7 6 1 5 8   看到了吧，把8放到最后去啦~~前面的依旧重新自己调整为大顶堆
  pop_heap(v.begin(),v.end()-1);     //把7也取出来吧 如果再也不想看到8，你就把vector最后一个erase掉
  for(int i = 0; i < v.size(); ++i)
  {
    cout << v[i] << " ";
  }
  cout << endl;                     //输出结果 6 5 1 7 8 
  v.push_back(1000);
 push_heap(v.begin(),v.end());    //输出结果 1000 5 6 7 8 1   （先往vector尾端插入再push_heap）
}

记住两点

（1）pop_heap发生在开始位置(它最大嘛)，push_heap在最后。

（2）pop和push前都得保证它是一个heap啊！都不是一个heap了操作它也没意义了啊
一直pop_heap会怎么样啊？对，就是heap从小到大排序。下面是STL sort_heap实现代码:

sort_heap(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
{
  __STL_REQUIRES(_RandomAccessIterator, _Mutable_RandomAccessIterator);
  while (__last - __first > 1)
    pop_heap(__first, __last--, __comp);
}

那么如何创建出一个大顶堆。（需要小顶堆可传入compare比较函数）

template <class _RandomAccessIterator, class _Tp, class _Distance>
void 
__make_heap(_RandomAccessIterator __first,
            _RandomAccessIterator __last, _Tp*, _Distance*)
{
  if (__last - __first < 2) return;         //没有或者只有1个元素不用排序了
  _Distance __len = __last - __first;       //有多少个元素保存起来，作越界判断
  _Distance __parent = (__len - 2)/2;      //从后往前开始，取出最后一个parent
  while (true) {
   //把这个value放到一个合适的位置。先放着略过，等下分析这个
  __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent))); 
  if (__parent == 0) return; 
  __parent--; //一个个节点来吧，感觉好费啊
 }
}

最最重要的函数 __adjust_heap，功能是把当前节点子树调整为一个大顶堆树。

它主要的思想是这样的：

把要调整的节点的值先取出来，就是这个参数value，然后把这个节点当做空节点，把max(left_child,right_child)大的孩子值放入这个位置，然后位置下移一层（二叉树的度），赋值的那个孩子再次当做parent，他的值已经给上一层了，所以他变成空节点了，他也得从孩子节点选大的来填充，如此循环下去到最大深度的叶子节点，child就都小于等于parent啦~~

还有一个最开始的value呢？最后把这个value放到最下层的那个空节点，然后让他一点一点往上和parent比较往上移动吧

template <class _RandomAccessIterator, class _Distance, class _Tp>
void 
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value)
{
  _Distance __topIndex = __holeIndex;                           //把这个index当做根节点（子树）
  _Distance __secondChild = 2 * __holeIndex + 2;                //把right_child取出来
  while (__secondChild < __len) {
    if (*(__first + __secondChild) < *(__first + (__secondChild - 1))) //left_child和right_child选出大的
      __secondChild--;
    *(__first + __holeIndex) = *(__first + __secondChild);     //胜者才有资格放入parent
    __holeIndex = __secondChild;
    __secondChild = 2 * (__secondChild + 1);                  //继续往下遍历right_child吧
  }
  //_seondChild是0开始的下标，最后一个叶子节点的处理，如果只有left_child才会出现等于
  if (__secondChild == __len) 
  { 
    *(__first + __holeIndex) = *(__first + (__secondChild - 1)); //没right_child和你争了
     __holeIndex = __secondChild - 1; 
  } 
  __push_heap(__first, __holeIndex, __topIndex, __value); //一层一层往上爬。 
 //（注侯捷老师的注解 可换成*(first + holeIndex) = value，有误，不能换。make_heap没问题但是pop_heap有问题）
}

</pre><pre>

看看怎么爬的吧。。

__push_heap(_RandomAccessIterator __first,
            _Distance __holeIndex, _Distance __topIndex, _Tp __value)
{
  _Distance __parent = (__holeIndex - 1) / 2;
  while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
    *(__first + __holeIndex) = *(__first + __parent);          //战胜parent把他换下来~~
    __holeIndex = __parent;
    __parent = (__holeIndex - 1) / 2;
  }    
  *(__first + __holeIndex) = __value;                        //最后终于找到合适的位置了
}

pop_heap也贴一下

template <class _RandomAccessIterator, class _Tp>
inline void 
__pop_heap_aux(_RandomAccessIterator __first, _RandomAccessIterator __last,
               _Tp*)
{
  __pop_heap(__first, __last - 1, __last - 1, 
             _Tp(*(__last - 1)), __DISTANCE_TYPE(__first)); //*(last-1)把最后那个值取出来

}

template <class _RandomAccessIterator, class _Tp, class _Distance>
inline void 
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
           _RandomAccessIterator __result, _Tp __value, _Distance*)
{
  //把最大值放到最后去，最后那个值是已经取出来过的(__value)~不怕
  *__result = *__first;
  //都去抢那个空位置去吧，该函数最后一行处理一下这个可能真的是很大的value哦
  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
 }

个人总结：挖空节点一个再处理，把它保存起来，调动其他节点的处理。make_heap感觉有点费，make_heap while遍历处理节点比较过多。