构建堆的算法

实际上，该表是通过越界索引访问的。

if (l <= heap2.heap_size || heap2.tab[l] > heap2.tab[i])
                         ^^

我想你在这种情况下指的是&&。

下一个r分支相同。

如果您仍然有问题，下面是我自己的实现，您可以使用作为参考。它也是基于Cormen等人的书，所以它使用了或多或少相同的术语。它可以为实际容器、比较函数和交换函数提供任意类型。它提供了一个公共的类似队列的接口，包括键递增。

因为它是一个更大的软件集合的一部分，它使用了一些这里没有定义的实体，但我希望算法仍然清晰。CHECK只是一个断言机制，您可以忽略它。你也可以忽略swap成员，只使用std::swap。

代码的某些部分使用基于1的偏移量，其他部分使用基于0的偏移量，因此需要进行转换。每个方法上面的注释都表明了这一点。

template <
    typename T,
    typename ARRAY = array <T>,
    typename COMP = fun::lt,
    typename SWAP = fun::swap
>
class binary_heap_base
{
protected:
    ARRAY a;
    size_t heap_size;
    SWAP swap_def;
    SWAP* swap;
    // 1-based
    size_t parent(const size_t n) { return n / 2; }
    size_t left  (const size_t n) { return n * 2; }
    size_t right (const size_t n) { return n * 2 + 1; }
    // 1-based
    void heapify(const size_t n = 1)
    {
        T& x = a[n - 1];
        size_t l = left(n);
        size_t r = right(n);
        size_t select =
            (l <= heap_size && COMP()(x, a[l - 1])) ?
            l : n;
        if (r <= heap_size && COMP()(a[select - 1], a[r - 1]))
            select = r;
        if (select != n)
        {
            (*swap)(x, a[select - 1]);
            heapify(select);
        }
    }
    // 1-based
    void build()
    {
        heap_size = a.length();
        for (size_t n = heap_size / 2; n > 0; n--)
            heapify(n);
    }
    // 1-based
    size_t advance(const size_t k)
    {
        size_t n = k;
        while (n > 1)
        {
            size_t pn = parent(n);
            T& p = a[pn - 1];
            T& x = a[n - 1];
            if (!COMP()(p, x)) break;
            (*swap)(p, x);
            n = pn;
        }
        return n;
    }
public:
    binary_heap_base() { init(); set_swap(); }
    binary_heap_base(SWAP& s) { init(); set_swap(s); }
    binary_heap_base(const ARRAY& a) { init(a); set_swap(); }
    binary_heap_base(const ARRAY& a, SWAP& s) { init(a); set_swap(s); }
    void init() { a.init(); build(); }
    void init(const ARRAY& a) { this->a = a; build(); }
    void set_swap() { swap = &swap_def; }
    void set_swap(SWAP& s) { swap = &s; }
    bool empty() { return heap_size == 0; }
    size_t size() { return heap_size; }
    size_t length() { return heap_size; }
    void reserve(const size_t len) { a.reserve(len); }
    const T& top()
    {
        CHECK (heap_size != 0, eshape());
        return a[0];
    }
    T pop()
    {
        CHECK (heap_size != 0, eshape());
        T x = a[0];
        (*swap)(a[0], a[heap_size - 1]);
        heap_size--;
        heapify();
        return x;
    }
    // 0-based
    size_t up(size_t n, const T& x)
    {
        CHECK (n < heap_size, erange());
        CHECK (!COMP()(x, a[n]), ecomp());
        a[n] = x;
        return advance(n + 1) - 1;
    }
    // 0-based
    size_t push(const T& x)
    {
        if (heap_size == a.length())
            a.push_back(x);
        else
            a[heap_size] = x;
        return advance(++heap_size) - 1;
    }
};