本文假设你已对堆排序的算法有主要的了解。
要分析stl中heap的源代码的独到之处。最好的办法就是拿普通的代码进行比較。话不多说，先看一段普通的堆排序的代码：

//调整大顶堆。使得结构合理
void max_heap(int a[],int node,int size)
{
    int lg=node;
    int l=node*2;
    int r=node*2+1;
    if(l<=size&&a[lg]<a[l])
    {
        lg=l;
    }
    if(r<=size&&a[lg]<a[r])
    {
        lg=r;
    }
    if(lg!=node)
    {
        //a[lg]=a[lg]^a[node];//交换
        //a[node]=a[lg]^a[node];
        //a[lg]=a[lg]^a[node];
        int tt=a[lg];
        a[lg]=a[node];
        a[node]=tt;

        max_heap(a,lg,size);
    }
}
//生成一个大顶堆
void make_heap(int a[],int size)
{
    for(int i=size/2;i>0;i--)
    {
        max_heap(a,i,size);
    }
}
//堆排序，使数据在数组中按从小到大的顺序排列
void heap_sort(int a[],int size)
{
    make_heap(a,size);
    for(int i=1;i<size;i++)
    {
        int tt=a[1];
        a[1]=a[size-i+1];
        a[size-i+1]=tt;
        max_heap(a,1,size-i);
    }
}

相应第一个函数max_heap()，stl中有一个功能相似的函数adjust_heap()，也是调整整个heap，使之符合大顶堆的要求，代码例如以下：

// ============================================================================
// 保持堆的性质
//整个的过程是从根节点開始，将根节点和其子节点中的最大值对调，一直到叶节点为止(称之为下溯)
//然后。再从这个根节点開始。把它与其父节点进行比較，假设比父节点大，则父子节点对调。直到根节点为止(称之为上溯)
//============================================================================
// first 起始位置
// holeIndex 要进行调整操作的位置
// len 长度
// value holeIndex新设置的值
template <class _RandomAccessIterator, class _Distance, class _Tp>
void 
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value)
{
    // 当前根节点的索引值
    _Distance __topIndex = __holeIndex;
    // 右孩子节点的索引值
    _Distance __secondChild = 2 * __holeIndex + 2;
    // 假设没有到末尾
    while (__secondChild < __len) {
        // 假设右孩子节点的值比左孩子节点的值要小。那么secondChild指向左孩子
        if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
            __secondChild--;
        // 子节点的往上升
        *(__first + __holeIndex) = *(__first + __secondChild);
        // 继续处理
        __holeIndex = __secondChild;
        __secondChild = 2 * (__secondChild + 1);
    }
    // 假设没有右子节点
    if (__secondChild == __len) {
        *(__first + __holeIndex) = *(__first + (__secondChild - 1));
        __holeIndex = __secondChild - 1;
    }
    // 针对节点topIndex调用push_heap操作
    __push_heap(__first, __holeIndex, __topIndex, __value);
}
//上溯
__push_heap(_RandomAccessIterator __first,
            _Distance __holeIndex, _Distance __topIndex, _Tp __value)
{
    // 获取父节点的索引值
    _Distance __parent = (__holeIndex - 1) / 2;
    // 假设还没有上升到根节点，且父节点的值小于待插入节点的值
    while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
        // 父节点下降到holeIndex
        *(__first + __holeIndex) = *(__first + __parent);
        // 继续往上检查
        __holeIndex = __parent;
        __parent = (__holeIndex - 1) / 2;
    }
    // 插入节点
    *(__first + __holeIndex) = __value;
}

stl里算法的堆的调整的主要流程如凝视里所说，主要是先进行下溯。直到叶节点，然后用push_heap进行上溯才调增完毕。对照之前的普通代码，主要有3点改变：

1. 把普通代码的递归操作变成了循环操作。这点非常好理解，由于递归须要系统使用资源来维护递归栈，开销比較大，所以stl中除了sort的快排之外(由于快排的递归深度有限制)。一般都会把递归的算法转换成循环来做。

2. 普通代码中，我们直接比較根节点和左右节点的值。然后假设须要的话跟节点直接和较大的节点交换，这样仅仅须要从上到下一趟比較。就能完毕树的调整。而stl的代码中，则要先下溯。然后再上溯。两趟才干完毕调整，看起来反而效率更低了，为什么呢？我细致分析了代码，感觉可能有一下两点的原因：1.代码的复用，由于下溯的主要作用事实上在保证大顶堆性质的前提下，让要调整的那个节点从根节点開始下沉。造成了一个新插入节点的假象。而push_heap()正是为了应对新插入节点而写的一个函2.数。这就复用了这块的代码。

   2.效率上的一点提升，由于下溯的过程仅仅须要两个子节点的一次比較和根节点的一次赋值，而上溯的过程也仅仅须要与根节点的一次比較和子节点的一次赋，所以合起来事实上是两次赋值和两次比較；而普通的代码中，假设不考虑边界检查。找出三个点里的最大值，并与之交换，则至少须要两次比較，和三次赋值，所以stl的算法中，赋值运算少了一次，效率有所提升。

3. 普通代码中，每次都须要对左子节点和右子节点进行边界的检查。而stl代码中。仅仅对右子节点进行边界检查，为了防止右子节点越界而左子节点没有越界的情况发生，在循环结束后添加了对左子节点的边界检查。这一改动大幅度降低了边界检查的次数，明显提升了效率。

通过上述的分析，事实上我们也能够以小见大。

事实上stl中，存在着大量这种优化，递归转循环，降低边界检查，用赋值取代交换等等。假设我们能细致研究，并在平时的编码中也养成这种习惯，就能极大得提升代码的效率。