FixedPriorityQueue.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_INCLUDE_FIXEDPRIORITYQUEUE_HPP
#define SOLIDUTILS_INCLUDE_FIXEDPRIORITYQUEUE_HPP

#include "Array.hpp"

namespace sl
{


template<typename K, typename V>
class FixedPriorityQueue
{
  public:
    static constexpr size_t const NULL_INDEX = static_cast<size_t>(-1);

    class ValueSet
    {
      public:
      class Iterator
      {
        public:
        Iterator(
            size_t const index,
            FixedPriorityQueue<K,V> const * const q) :
          m_index(index),
          m_q(q)
        {
          // do nothing
        }

        inline V operator*() const noexcept
        {
          size_t const pos = m_q->m_index[m_index];
          return m_q->m_data[pos].value;
        }

        inline Iterator & operator++()
        {
          do {
            ++m_index;
          } while (m_index < m_q->m_index.size() && \
              m_q->m_index[m_index] == NULL_INDEX);

          return *this;
        }

        inline bool operator==(
            Iterator const & other) const
        {
          return m_index == other.m_index;
        }

        inline bool operator!=(
            Iterator const & other) const
        {
          return !(*this == other);
        }

        private:
        size_t m_index;
        FixedPriorityQueue<K,V> const * m_q;
      };

      ValueSet(
          FixedPriorityQueue<K,V> const * const q) :
        m_q(q)
      {
        // do nothing
      }

      inline Iterator begin() const noexcept
      {
        // find first valid index
        size_t index = 0;
        while (index < m_q->m_index.size() && \
            m_q->m_index[index] == NULL_INDEX) {
          ++index;
        }

        return Iterator(index, m_q);
      }

      inline Iterator end() const noexcept
      {
        return Iterator(m_q->m_index.size(), m_q);
      }

      private:
      FixedPriorityQueue<K,V> const * m_q;
    };

    FixedPriorityQueue(
        V const max) :
      m_data(max),
      m_index(max, NULL_INDEX),
      m_size(0)
    {
      // do nothing
    }


    void remove(
        V const value) noexcept
    {
      ASSERT_LESS(static_cast<size_t>(value), m_index.size());
      ASSERT_NOTEQUAL(m_index[value], NULL_INDEX);

      // remove item from heap and sort up
      size_t const index = m_index[value];
      fill(index);
    }


    void add(
        K const key,
        V const value) noexcept
    {
      ASSERT_LESS(static_cast<size_t>(value), m_index.size());
      ASSERT_EQUAL(m_index[value], NULL_INDEX);

      size_t const index = m_size++;
      m_index[value] = index;
      m_data[index].key = key;
      m_data[index].value = value;

      siftUp(index);
    }


    void update(
        K const key,
        V const value) noexcept
    {
      ASSERT_LESS(static_cast<size_t>(value), m_index.size());
      ASSERT_NOTEQUAL(m_index[value], NULL_INDEX);

      size_t const index = m_index[value];
      m_data[index].key = key;

      // update position
      if (index > 0 && key > m_data[parentIndex(index)].key) {
        siftUp(index);
      } else {
        siftDown(index);
      }
    }


    void updateByDelta(
        K const delta,
        V const value) noexcept
    {
      ASSERT_LESS(static_cast<size_t>(value), m_index.size());
      ASSERT_NOTEQUAL(m_index[value], NULL_INDEX);

      size_t const index = m_index[value];
      K const key = m_data[index].key + delta;

      update(key, value);
    }

    bool contains(
        V const value) const noexcept
    {
      ASSERT_LESS(static_cast<size_t>(value), m_index.size());

      return m_index[value] != NULL_INDEX;
    }


    K get(
        V const value) const noexcept
    {
      ASSERT_LESS(static_cast<size_t>(value), m_index.size());
      ASSERT_NOTEQUAL(m_index[value], NULL_INDEX);

      return m_data[m_index[value]].key;
    }


    V pop() noexcept
    {
      ASSERT_GREATER(m_size, 0);

      V const value = m_data[0].value;
      fill(0);

      return value;
    }


    V const & peek() const noexcept
    {
      return m_data[0].value;
    }


    K const & max() const noexcept
    {
      return m_data[0].key;
    }


    size_t size() const noexcept
    {
      return m_size;
    }


    void clear() noexcept
    {
      for (size_t i = 0; i < m_size; ++i) {
        m_index[m_data[i].value] = NULL_INDEX;
      }
      m_size = 0;
    }


    ValueSet remaining() const noexcept
    {
      return ValueSet(this);
    }


  private:
    struct kv_pair_struct
    {
      K key;
      V value;
    };

    Array<kv_pair_struct> m_data;
    Array<size_t> m_index;
    size_t m_size;


    size_t parentIndex(
        size_t const index) const noexcept
    {
      return index / 2;
    }


    size_t leftChildIndex(
        size_t const index) const noexcept
    {
      return (index * 2)+1;
    }


    size_t rightChildIndex(
        size_t const index) const noexcept
    {
      return leftChildIndex(index) + 1;
    }


    void swap(
        size_t const indexA,
        size_t const indexB) noexcept
    {
      V const valueA = m_data[indexA].value;
      V const valueB = m_data[indexB].value;

      std::swap(m_index[valueA], m_index[valueB]);
      std::swap(m_data[indexA], m_data[indexB]);
    }


    void fill(
        size_t const index) noexcept
    {
      ASSERT_LESS(index, m_size);

      --m_size;
      V const deletedValue = m_data[index].value;

      if (m_size > 0) {
        // what we'll do is move the bottom node to this position
        m_data[index] = m_data[m_size];

        V const value = m_data[index].value;
        m_index[value] = index;

        siftDown(index);
      }

      m_index[deletedValue] = NULL_INDEX;
    }


    void siftUp(
        size_t index) noexcept
    {
      while (index > 0) {
        size_t const parent = parentIndex(index);
        if (m_data[parent].key >= m_data[index].key) {
          // reached a valid state
          break;
        }
        swap(index, parent);
        index = parent;
      }
    }


    void siftDown(
        size_t index) noexcept
    {
      K const key = m_data[index].key;
      while (true) {
        size_t const leftIndex = leftChildIndex(index);
        size_t const rightIndex = rightChildIndex(index);
        if (rightIndex < m_size && key < m_data[rightIndex].key) {
          if (m_data[rightIndex].key >= m_data[leftIndex].key) {
            swap(index, rightIndex);
            index = rightIndex;
          } else {
            swap(index, leftIndex);
            index = leftIndex;
          }
        } else if (leftIndex < m_size && key < m_data[leftIndex].key) {
          swap(index, leftIndex);
          index = leftIndex;
        } else {
          // life is good -- exit
          break;
        }
      }
    }
};


}

#endif