c++数据结构——堆（可重载规则）

使用了模板函数指针，默认指向模板类静态成员函数

#include <iostream>
#include <vector>
using namespace std;

template <typename T>
class Heap {
          
   
  private:
    static bool les_(const T &l, const T &r) {
          
    return l < r; }
    static bool greater_(const T &l, const T &r) {
          
    return l > r; }

  private:
    vector<T> data_;
    bool (*cmp_)(const T &l, const T &r);

    void push_up() {
          
   
        if (data_.size() <= 1) return;
        int i = data_.size() - 1, tmp = data_[i];
        while (i > 0) {
          
   
            int nex = i / 2;
            if (cmp_(tmp, data_[nex])) break;
            data_[i] = data_[nex], i = nex;
        }
        data_[i] = tmp;
    }

    void push_down() {
          
   
        if (data_.size() <= 1) return;
        int i = 0, tmp = data_[i];
        while (i * 2 < data_.size()) {
          
   
            int nex = i * 2 + (i * 2 + 1 < data_.size() && cmp_(data_[i * 2], data_[i * 2 + 1]));
            if (cmp_(data_[nex], tmp)) break;
            data_[i] = data_[nex], i = nex;
        }
        data_[i] = tmp;
    }

  public:
    Heap(bool less = 1) {
          
    cmp_ = less ? les_ : greater_; }
    Heap(bool (*p)(const T &, const T &)) {
          
    cmp_ = p; }
    ~Heap() {
          
   }

    void push(T x) {
          
   
        data_.push_back(x);
        push_up();
    }

    void pop() {
          
   
        if (data_.empty()) return;
        data_[0] = data_.back();
        data_.pop_back();
        push_down();
    }

    T top() {
          
    return data_[0]; }
    int size() {
          
    return data_.size(); }
};

template <typename T>
bool les_(const T &l, const T &r) {
          
    return l < r; }

int main() {
          
   
    Heap<int> a(les_);
    a.push(1);
    a.push(3);
    a.push(4);
    a.push(6);
    a.push(5);
    a.push(2);
    while (a.size()) {
          
   
        cout << a.top() << endl;
        a.pop();
    }
}