算法导论第三版--堆的生成，排序，插入

这两年一直埋首在C相关的代码中，都快忘记自己曾经热爱并赖以南征北战过的C++了，而且C++11出来那么久了，瞄了几眼，没练过都不敢说自己会C++了，

正好很多基础算法没正经的学习过，打算逐个（算法导论里的）用C++完成一遍好好练练手。（其实没那么多时间，能写几个就写几个啦，加之水平有限）

结果呢，一动起手来，还是觉得实现算法呢，还是C看起来舒服，C++反而不直观了，咋的整呢，管不了那么多了，写几行看看吧。

嗯，工欲善其事必先利其器，这里推荐编辑器code::blocks+mingw，清新好用，（当然vs更好用，不过你懂的啦），博主最后还是回到了eclipse的怀抱，refactor，debug功能比code::blocks好一点

堆有2种，最大堆和最小堆，其实就是一个比较因子的不同，算法描述是一样的。

heapify函数用来保持堆的特性，比如：

1、父节点总是大于子节点这是最大堆，反之，父节点总是小于子节点是最小堆

2、使用数组或者vector来实现堆比较方便，索引为i的元素，父节点就是i/2，左子节点是2*i，右子节点是2*i+1，i>=1。

3、插入一个新元素，在尾部插入最快，但是可能会破坏堆的特性，因此要注意重新保持堆的特性

另外，采用C++也有很多方便之处，比如有现成的functor可以使用。这只是个例子，请在实际工作中谨慎选择合适的数据结构或者容器。

#include <iostream>
#include <vector>
#include <cmath>
#include <cassert>
#include <functional>

using std::floor;
using std::swap;
using std::vector;
using std::greater;
using std::less;

template<typename _InIt, typename _Func>
void heapify(_InIt first, _InIt last, _InIt ite, _Func& Func) {
    int i = ite - first;
    _InIt it = ite;

    if ((last-ite)>i && Func(*(ite+i), *(it))) {
        it = ite + i;
    }

    if ((last-ite)>(i+1) && Func(*(ite+i+1), *(it))) {
        it = ite + i + 1;
    }

    if (*it != *ite) {
        swap(*ite, *it);
        heapify(first, last, it, Func);
    }
}

template<typename _InIt, typename _Func>
void build_heap(_InIt first, _InIt last, _Func &Func) {
    int i = (int)floor((float)(last - first)/2);
    for (; i>0; i--) {
        heapify(first, last, first+i, Func);
    }
}

template<typename _InIt, typename _Func>
void heap_sort(_InIt first, _InIt last, _Func &Func) {
    for (_InIt it=(last-1); it != (first+1); --it) {
        swap(*(first+1), *it);
        heapify(first, it, first+1, Func);
    }
}

template<typename T, typename _Func>
T heap_extract(vector<T> &v, _Func &Func) {
    assert(v.size() >= 2);  /* 因为多了一个填充元素 */   

    typename vector<T>::iterator it = v.begin() + 1;  /* 没有加typename gcc会报错 */
    T target = *(it);

    v.erase(it);
    heapify(v.begin(), v.end(), v.begin()+1, Func);
    return target;
}

template<typename T, typename _Func>
void heap_increase_key(vector<T>& v, _Func &Func, int i, T key) {
    v[i] = key;
    while(i>1 && !Func(v[i/2], v[i])) {
        swap(v[i], v[i/2]);
        i >>= 1;
    }
}

template<typename T, typename _Func>
void heap_insert(vector<T> &v, T key, _Func &Func) {
    v.push_back(key);
    heap_increase_key(v, Func, v.size()-1, key);
}

int main(int argc,  char* argv[]) {
    /* 堆的索引是1开始，所以第一个元素0是用来占位的 */
    int lst[] = {0,3,7,8,14,2,1,9,4,10,16};   
    vector<int> v(lst, lst+11);

    less<int> c;
    build_heap(v.begin(), v.end(), c);

    std::cout << heap_extract(v, c) << std::endl;
    heap_sort (v.begin(), v.end(), c);

    for (vector<int>::iterator it=v.begin(); it!=v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

参考： 算法导论