mirror of
https://github.com/OpenTTD/OpenTTD.git
synced 2025-08-12 09:09:09 +00:00
(svn r4987) Feature: Merged YAPF into trunk. Thanks to devs for continuous support and users for testing.
This commit is contained in:
KUDr
230
yapf/binaryheap.hpp
Normal file
230
yapf/binaryheap.hpp
Normal file
@@ -0,0 +1,230 @@
|
||||
/* $Id$ */
|
||||
|
||||
#ifndef BINARYHEAP_HPP
|
||||
#define BINARYHEAP_HPP
|
||||
|
||||
#include <new>
|
||||
|
||||
//void* operator new (size_t size, void* p) {return p;}
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
|
||||
//void operator delete (void* p, void* p2) {}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
* Binary Heap as C++ template.
|
||||
*
|
||||
* For information about Binary Heap algotithm,
|
||||
* see: http://www.policyalmanac.org/games/binaryHeaps.htm
|
||||
*
|
||||
* Implementation specific notes:
|
||||
*
|
||||
* 1) It allocates space for item pointers (array). Items are allocated elsewhere.
|
||||
*
|
||||
* 2) ItemPtr [0] is never used. Total array size is max_items + 1, because we
|
||||
* use indices 1..max_items instead of zero based C indexing.
|
||||
*
|
||||
* 3) Item of the binary heap should support these public members:
|
||||
* - 'lower-then' operator '<' - used for comparing items before moving
|
||||
*
|
||||
*/
|
||||
|
||||
template <class Titem_>
|
||||
class CBinaryHeapT {
|
||||
public:
|
||||
typedef Titem_ *ItemPtr;
|
||||
private:
|
||||
int m_size; ///< Number of items in the heap
|
||||
int m_max_size; ///< Maximum number of items the heap can hold
|
||||
ItemPtr* m_items; ///< The heap item pointers
|
||||
|
||||
public:
|
||||
explicit CBinaryHeapT(int max_items = 102400)
|
||||
: m_size(0)
|
||||
, m_max_size(max_items)
|
||||
{
|
||||
m_items = new ItemPtr[max_items + 1];
|
||||
}
|
||||
|
||||
~CBinaryHeapT()
|
||||
{
|
||||
Clear();
|
||||
delete [] m_items;
|
||||
m_items = NULL;
|
||||
}
|
||||
|
||||
public:
|
||||
/** Return the number of items stored in the priority queue.
|
||||
* @return number of items in the queue */
|
||||
FORCEINLINE int Size() const {return m_size;};
|
||||
|
||||
/** Test if the priority queue is empty.
|
||||
* @return true if empty */
|
||||
FORCEINLINE bool IsEmpty() const {return (m_size == 0);};
|
||||
|
||||
/** Test if the priority queue is full.
|
||||
* @return true if full. */
|
||||
FORCEINLINE bool IsFull() const {return (m_size >= m_max_size);};
|
||||
|
||||
/** Find the smallest item in the priority queue.
|
||||
* Return the smallest item, or throw assert if empty. */
|
||||
FORCEINLINE Titem_& GetHead() {assert(!IsEmpty()); return *m_items[1];}
|
||||
|
||||
/** Insert new item into the priority queue, maintaining heap order.
|
||||
* @return false if the queue is full. */
|
||||
bool Push(Titem_& new_item);
|
||||
|
||||
/** Remove and return the smallest item from the priority queue. */
|
||||
FORCEINLINE Titem_& PopHead() {Titem_& ret = GetHead(); RemoveHead(); return ret;};
|
||||
|
||||
/** Remove the smallest item from the priority queue. */
|
||||
void RemoveHead();
|
||||
|
||||
/** Remove item specified by index */
|
||||
void RemoveByIdx(int idx);
|
||||
|
||||
/** return index of the item that matches (using &item1 == &item2) the given item. */
|
||||
int FindLinear(const Titem_& item) const;
|
||||
|
||||
/** Make the priority queue empty.
|
||||
* All remaining items will remain untouched. */
|
||||
void Clear() {m_size = 0;};
|
||||
|
||||
/** verifies the heap consistency (added during first YAPF debug phase) */
|
||||
void CheckConsistency();
|
||||
};
|
||||
|
||||
|
||||
template <class Titem_>
|
||||
FORCEINLINE bool CBinaryHeapT<Titem_>::Push(Titem_& new_item)
|
||||
{
|
||||
if (IsFull()) return false;
|
||||
|
||||
// make place for new item
|
||||
int gap = ++m_size;
|
||||
// Heapify up
|
||||
for (int parent = gap / 2; (parent > 0) && (new_item < *m_items[parent]); gap = parent, parent /= 2)
|
||||
m_items[gap] = m_items[parent];
|
||||
m_items[gap] = &new_item;
|
||||
CheckConsistency();
|
||||
return true;
|
||||
}
|
||||
|
||||
template <class Titem_>
|
||||
FORCEINLINE void CBinaryHeapT<Titem_>::RemoveHead()
|
||||
{
|
||||
assert(!IsEmpty());
|
||||
|
||||
// at index 1 we have a gap now
|
||||
int gap = 1;
|
||||
|
||||
// Heapify down:
|
||||
// last item becomes a candidate for the head. Call it new_item.
|
||||
Titem_& new_item = *m_items[m_size--];
|
||||
|
||||
// now we must maintain relation between parent and its children:
|
||||
// parent <= any child
|
||||
// from head down to the tail
|
||||
int child = 2; // first child is at [parent * 2]
|
||||
|
||||
// while children are valid
|
||||
while (child <= m_size) {
|
||||
// choose the smaller child
|
||||
if (child < m_size && *m_items[child + 1] < *m_items[child])
|
||||
child++;
|
||||
// is it smaller than our parent?
|
||||
if (!(*m_items[child] < new_item)) {
|
||||
// the smaller child is still bigger or same as parent => we are done
|
||||
break;
|
||||
}
|
||||
// if smaller child is smaller than parent, it will become new parent
|
||||
m_items[gap] = m_items[child];
|
||||
gap = child;
|
||||
// where do we have our new children?
|
||||
child = gap * 2;
|
||||
}
|
||||
// move last item to the proper place
|
||||
if (m_size > 0) m_items[gap] = &new_item;
|
||||
CheckConsistency();
|
||||
}
|
||||
|
||||
template <class Titem_>
|
||||
inline void CBinaryHeapT<Titem_>::RemoveByIdx(int idx)
|
||||
{
|
||||
// at position idx we have a gap now
|
||||
int gap = idx;
|
||||
Titem_& last = *m_items[m_size];
|
||||
if (idx < m_size) {
|
||||
assert(idx >= 1);
|
||||
m_size--;
|
||||
// and the candidate item for fixing this gap is our last item 'last'
|
||||
// Move gap / last item up:
|
||||
while (gap > 1)
|
||||
{
|
||||
// compare [gap] with its parent
|
||||
int parent = gap / 2;
|
||||
if (last < *m_items[parent]) {
|
||||
m_items[gap] = m_items[parent];
|
||||
gap = parent;
|
||||
} else {
|
||||
// we don't need to continue upstairs
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Heapify (move gap) down:
|
||||
while (true) {
|
||||
// where we do have our children?
|
||||
int child = gap * 2; // first child is at [parent * 2]
|
||||
if (child > m_size) break;
|
||||
// choose the smaller child
|
||||
if (child < m_size && *m_items[child + 1] < *m_items[child])
|
||||
child++;
|
||||
// is it smaller than our parent?
|
||||
if (!(*m_items[child] < last)) {
|
||||
// the smaller child is still bigger or same as parent => we are done
|
||||
break;
|
||||
}
|
||||
// if smaller child is smaller than parent, it will become new parent
|
||||
m_items[gap] = m_items[child];
|
||||
gap = child;
|
||||
}
|
||||
// move parent to the proper place
|
||||
if (m_size > 0) m_items[gap] = &last;
|
||||
}
|
||||
else {
|
||||
assert(idx == m_size);
|
||||
m_size--;
|
||||
}
|
||||
CheckConsistency();
|
||||
}
|
||||
|
||||
template <class Titem_>
|
||||
inline int CBinaryHeapT<Titem_>::FindLinear(const Titem_& item) const
|
||||
{
|
||||
if (IsEmpty()) return 0;
|
||||
for (ItemPtr *ppI = m_items + 1, *ppLast = ppI + m_size; ppI <= ppLast; ppI++) {
|
||||
if (*ppI == &item) {
|
||||
return ppI - m_items;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <class Titem_>
|
||||
FORCEINLINE void CBinaryHeapT<Titem_>::CheckConsistency()
|
||||
{
|
||||
// enable it if you suspect binary heap doesn't work well
|
||||
#if 0
|
||||
for (int child = 2; child <= m_size; child++) {
|
||||
int parent = child / 2;
|
||||
assert(!(m_items[child] < m_items[parent]));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#endif /* BINARYHEAP_HPP */
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user