tpl_arrayHeap.H

Go to the documentation of this file.

/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
#ifndef TPL_ARRAYHEAP_H
#define TPL_ARRAYHEAP_H
 
#include <ah-concepts.H>
#include <algorithm>
#include <cstddef>
#include <stdexcept>
#include <utility>
 
#include <ahFunction.H>
#include <ahUtils.H>
#include <ahDefs.H>
#include <ahAssert.H>
#include <array_it.H>
#include <htlist.H>
#include <tpl_dynDlist.H>
#include <ah-args-ctor.H>
#include <ahDry.H>
#include <ah-dry.H>
#include <ah-errors.H>
 
namespace Aleph
{
  template <typename T, class Compare>
  inline
  T &sift_up(T *ptr, const size_t l, const size_t r, Compare & cmp)
  {
    size_t i = r;
    for (size_t p; i > l; i = p)
      {
        p = u_index(i); // parent index (p = i / 2)
 
        // Prefetch grandparent for next iteration
        if (const size_t gp = u_index(p); gp >= l)
          __builtin_prefetch(&ptr[gp], 0, 1);
 
        if (cmp(ptr[p], ptr[i])) [[likely]] // does the heap property hold?
            return ptr[i]; // yes, the entire range is already a heap
 
        std::swap(ptr[p], ptr[i]); // swap nodes and restore level p
      }
 
    return ptr[i];
  }
 
  template <typename T, class Compare>
  inline
  void sift_down(T *ptr, const size_t l, const size_t r, Compare & cmp)
  {
    size_t i = l;
    while (true)
      {
        size_t c = l_index(i); // left child index (c = 2 * i)
        if (c > r) [[unlikely]] // does it have a left child?
            return; // no ==> stop
 
        // Prefetch grandchildren for next iteration
        if (const size_t gc = l_index(c); gc <= r)
          __builtin_prefetch(&ptr[gc], 0, 1);
 
        if (c + 1 <= r) // does it have a right child?
          if (cmp(ptr[c + 1], ptr[c])) // yes ==> pick the smaller child
            c++;
 
        if (cmp(ptr[i], ptr[c])) [[likely]] // does the heap property hold?
            return; // yes ==> stop
 
        std::swap(ptr[c], ptr[i]);
        i = c;
      }
  }
 
  template <typename T, class Compare>
  inline
  void sift_down_up(T *ptr, const size_t l, const size_t i, const size_t r,
                    Compare & cmp)
  {
    sift_down<T, Compare>(ptr, i, r, cmp);
    sift_up<T, Compare>(ptr, l, i, cmp);
  }
 
  template <typename T, class Compare = Aleph::less<T>>
    requires StrictWeakOrder<Compare, T>
  inline
  void heapsort(T *array, const size_t n, const Compare & cmp = Compare())
  {
    Inversed_Compare<T, Compare> inv_cmp(cmp);
 
    --array; // shift backwards so array[1] is the first element
    for (size_t i = 2; i <= n; ++i)
      sift_up<T, Inversed_Compare<T, Compare>>(array, 1, i, inv_cmp);
    for (size_t i = n; i > 1; --i)
      {
        std::swap(array[1], array[i]); // place the i-th item at the root
        sift_down<T, Inversed_Compare<T, Compare>>(array, 1, i - 1, inv_cmp);
      }
  }
 
  template <typename T, class Compare = Aleph::less<T>>
    requires StrictWeakOrder<Compare, T>
  inline
  void faster_heapsort(T *array, const size_t n, const Compare & cmp = Compare())
  {
    Inversed_Compare<T, Compare> inv_cmp(cmp);
 
    --array; // shift backwards so array[1] is the first element
    for (size_t i = n / 2; i >= 1; --i)
      sift_down(array, i, n, inv_cmp);
    for (size_t i = n; i > 1; --i)
      {
        std::swap(array[1], array[i]); // place the i-th item at the root
        sift_down(array, 1, i - 1, inv_cmp);
      }
  }
 
  template <typename T, class Compare = Aleph::less<T>>
    requires StrictWeakOrder<Compare, T>
  bool valid_heap(T *array, const size_t l, const size_t r,
                  const Compare & cmp = Compare())
  {
    size_t i;
    for (i = l_index(l) /* i = 2*l */; i <= r; i++)
      if (cmp(array[i], array[u_index(i)]))
        break;
    return i > r;
  }
 
  template <typename T, class Compare = Aleph::less<T>>
    requires StrictWeakOrder<Compare, T>
  class ArrayHeap : public LocateFunctions<ArrayHeap<T, Compare>, T>,
                    public FunctionalMethods<ArrayHeap<T, Compare>, T>,
                    public GenericItems<ArrayHeap<T, Compare>, T>,
                    public EqualToMethod<ArrayHeap<T, Compare>>,
                    public StlAlephIterator<ArrayHeap<T, Compare>>
  {
    T *array = nullptr;
    mutable size_t dim = 0;
    size_t num_items = 0;
 
    mutable bool array_allocated = false;
 
    Compare cmp;
 
    static size_t r_index(const size_t & i)
    {
      return (i << 1) + 1; // multiply i by 2 and add 1
    }
 
  public:
    void allocate_storage(const size_t new_dim)
    {
      ah_invalid_argument_if(new_dim == 0) << "Heap capacity must be positive";
 
      T *ptr = new T[new_dim + 1];
      if (array_allocated)
        delete [] array;
 
      array = ptr;
      dim = new_dim;
      num_items = 0;
      array_allocated = true;
    }
 
    void swap(ArrayHeap & h) noexcept
    {
      std::swap(array, h.array);
      std::swap(dim, h.dim);
      std::swap(num_items, h.num_items);
      std::swap(array_allocated, h.array_allocated);
      std::swap(cmp, h.cmp);
    }
 
    using Item_Type = T;
 
    using Key_Type = T;
 
    Special_Ctors(ArrayHeap, T);
 
    ArrayHeap(const size_t d = 1024, Compare cmp_fct = Compare())
      : array(nullptr), cmp(cmp_fct)
    {
      allocate_storage(d);
    }
 
    ArrayHeap(T *ptr, const size_t & d, Compare cmp_fct = Compare())
      : array(ptr), dim(d), cmp(cmp_fct)
    {
      ah_invalid_argument_if(ptr == nullptr or d == 0) << "ArrayHeap requires non-null buffer";
    }
 
    ArrayHeap(const ArrayHeap & h)
      : array(nullptr), cmp(h.cmp)
    {
      allocate_storage(h.dim);
      num_items = h.num_items;
      for (size_t i = 1; i <= num_items; ++i)
        array[i] = h.array[i];
    }
 
    ArrayHeap(ArrayHeap && h) noexcept
      : cmp(h.cmp)
    {
      swap(h);
    }
 
    ArrayHeap &operator =(const ArrayHeap & h)
    {
      if (this == &h)
        return *this;
 
      if (dim < h.dim)
        allocate_storage(h.dim);
 
      num_items = h.num_items;
      for (size_t i = 1; i <= num_items; ++i)
        array[i] = h.array[i];
      cmp = h.cmp;
 
      return *this;
    }
 
    ArrayHeap &operator =(ArrayHeap && h)
      noexcept
    {
      swap(h);
      return *this;
    }
 
    virtual ~ArrayHeap()
    {
      if (array_allocated and array != nullptr)
        delete [] array;
    }
 
    T &top()
    {
      ah_underflow_error_if(num_items == 0) << "Heap is empty";
 
      return array[1];
    }
 
    const T &top() const
    {
      ah_underflow_error_if(num_items == 0) << "Heap is empty";
 
      return array[1];
    }
 
    T &insert_ne(const T & key)
    {
      array[++num_items] = key; // place the new element
      return sift_up(array, 1, num_items, cmp);
    }
 
    T &insert_ne(T && key)
    {
      array[++num_items] = std::move(key); // place the new element
      return sift_up(array, 1, num_items, cmp);
    }
 
    T &insert(const T & key)
    {
      ah_overflow_error_if(num_items >= dim) << "Heap out of capacity";
      return insert_ne(key);
    }
 
    T &insert(T && key)
    {
      ah_overflow_error_if(num_items >= dim) << "Heap out of capacity";
      return insert_ne(std::move(key));
    }
 
    T &put(const T & key) { return insert(key); }
 
    T &append(const T & key) { return insert(key); }
 
    T &put(T && key) { return insert(std::move(key)); }
 
    T &append(T && key) { return insert(std::move(key)); }
 
    T getMin()
    {
      ah_underflow_error_if(num_items == 0) << "Heap is empty";
 
      T ret_val = array[1];
      array[1] = array[num_items--];
      if (num_items > 0)
        sift_down(array, 1, num_items, cmp);
      return ret_val;
    }
 
    T get()
    {
      return getMin();
    }
 
    T getMax()
    {
      return getMin();
    }
 
    [[nodiscard]] constexpr size_t size() const noexcept { return num_items; }
 
    [[nodiscard]] constexpr bool is_empty() const noexcept { return num_items == 0; }
 
    [[nodiscard]] constexpr size_t capacity() const noexcept { return dim; }
 
    void update(T & data)
    {
      ah_underflow_error_if(num_items == 0) << "Heap is empty";
 
      assert(&data >= array + 1 and &data <= array + num_items);
 
      const auto i = static_cast<size_t>(&data - array);
      sift_down_up(array, 1, i, num_items, cmp);
    }
 
    void remove(T & item)
    {
      ah_underflow_error_if(num_items == 0) << "Heap is empty";
 
      assert(&item >= array + 1 and &item <= array + num_items);
 
      const auto idx = static_cast<size_t>(&item - array);
      if (idx == num_items)
        {
          --num_items;
          return;
        }
 
      array[idx] = std::move(array[num_items--]);
      sift_down_up(array, 1, idx, num_items, cmp);
    }
 
    T &operator [](const size_t i)
    {
      return array[i];
    }
 
    const T &operator [](const size_t i) const
    {
      return array[i];
    }
 
    struct Iterator : public Array_Iterator<T>
    {
      Iterator(const ArrayHeap & h) noexcept
        : Array_Iterator<T>(no_exception_ctor, h.array + 1, h.dim, h.num_items)
      { /* empty */
      }
    };
 
  private:
    // superfast array traversal
    template <class Operation>
    bool traverse_impl(Operation & operation)
    {
      for (size_t i = 1; i <= num_items; ++i)
        if (not operation(array[i]))
          return false;
 
      return true;
    }
 
  public:
    template <class Operation>
    bool traverse(Operation & operation) const
    {
      return const_cast<ArrayHeap &>(*this).traverse_impl(operation);
    }
 
    template <class Operation>
    bool traverse(Operation & operation)
    {
      return traverse_impl(operation);
    }
 
    template <class Operation>
    bool traverse(Operation && operation = Operation()) const
    {
      return const_cast<ArrayHeap &>(*this).traverse_impl(operation);
    }
 
    template <class Operation>
    bool traverse(Operation && operation = Operation())
    {
      return traverse_impl(operation);
    }
  };
} // end namespace Aleph
# endif /* TPL_ARRAYHEAP_H */