//+--------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1991 - 2001. // // File: HEAP.HXX // // Contents: heap // // Classes: CHeap // // History: 08-May-91 BartoszM Created // //---------------------------------------------------------------------------- #pragma once #ifdef DISPLAY_INCLUDES #pragma message( "#include <" __FILE__ ">..." ) #endif //+--------------------------------------------------------------------------- // // Class: CHeap // // Purpose: Heap of items: parametrized class // // Interface: // CHeap( int count, CItem * array[] ) // CHeap( int count ) // CHeap () // BOOL IsEmpty() // int Count() // CItem* GetVector() // CItem * Top() // CItem * RemoveTop() // CItem * RemoveBottom() // void Add ( CItem * item ) // void Reheap () // void MakeHeap () // void MakeHeap ( int count, CItem * array[] ) // // Notes: This heap can be used for any class of elements // provided there is a function that compares two elements. // This function can be defined inline. It takes two pointers // to elements to be compared and returns true if the first // element is less than the second one. The name of the // function is passed to the IMP_HEAP macro. // Both DEF_HEAP and IMP_HEAP take the name of the // heap class and the name of the element class as parameters. // All methods preserve the heap property (partial order). // Top element is accessible for manipulation. If its // value changes, Reheap should be called explicitly. // // Example: // class CFoo; // // comparison function // BOOL LessFoo ( CFoo * f1, CFoo * f2 ); // // Define class CFooHeap // DEF_HEAP ( CFooHeap, CFoo ) // // Implement methods of CFooHeap // IMP_HEAP ( CFooHeap, CFoo, LessFoo ) // // CFoo aFoo [10]; // // initialize the array // CFooHeap MyHeap ( 10, aFoo ); // CFoo* pFoo = MyHeap.Top(); // smallest element // pFoo->ChangeValue ( 13 ); // MyHeap.Reheap(); // reorder after manipulation // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- #define DEF_HEAP( CHeap, CItem ) \ class CHeap \ { \ public: \ CHeap():_end(-1), _item(0) {} \ CHeap( int count, CItem ** array ) \ : _end(count-1), _item(array) \ { MakeHeap(); } \ CHeap( int count ):_end(-1) \ { _item = new CItem* [count]; } \ ~CHeap(); \ BOOL IsEmpty() {return _end < 0;} \ CItem * Top() { return _item[0]; } \ CItem * RemoveTop(); \ CItem * RemoveTopKey(); \ __forceinline CItem * RemoveBottom() \ { \ if ( _end >= 0 ) \ return _item [_end--]; \ else \ return 0; \ } \ int Count() const { return _end+1;} \ CItem ** GetVector() { return _item;} \ void Add ( CItem * item ); \ void AddKey ( CItem * item, ULONG key ); \ void Reheap (); \ void ReheapKey (); \ void MakeHeap (); \ void MakeHeap ( int count, CItem ** array ) \ { _end=count-1; _item = array; MakeHeap(); } \ void CiExtDump(void *ciExtSelf); \ private: \ int _end; \ CItem ** _item; \ }; //+--------------------------------------------------------------------------- // // Member: CHeap::CHeap, public // // Synopsis: Make a heap from an array // // Arguments: [count] -- size of an array // [array] -- array of pointers to elements // // Notes: The size of the heap is fixed. No bound checking is done. // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::CHeap, public // // Synopsis: Create an empty heap of maximum size defined by count // // Arguments: [count] -- size of an array // // Notes: The size of the heap is fixed. No bound checking is done. // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::CHeap, public // // Synopsis: Create an empty heap // // Notes: To be used only in two-step construction -- see: MakeHeap // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::~CHeap, public // // Synopsis: Destroy the heap, delete all the elements. // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::IsEmpty, public // // Returns: TRUE if empty, FALSE otherwise // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::Top, public // // Returns: Top element or NULL if heap empty // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::RemoveBottom, public // // Synopsis: Remove last element. // // Returns: Bottom element of NULL if heap empty // // Notes: Used as destructive iterator. // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::RemoveTop, public // // Synopsis: Removes and returns top element // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::Add, public // // Synopsis: Add an element to the heap // // Arguments: [item] -- item to be added // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::Reheap, public // // Synopsis: Reheap after changing the top element (sifts down) // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::MakeHeap, public // // Synopsis: Make an ordered heap out of random array. // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- //+--------------------------------------------------------------------------- // // Member: CHeap::MakeHeap, public // // Synopsis: Make an ordered heap from array. // // Arguments: [count] -- size of an array // [array] -- array of pointers to elements // // Notes: Use only in two-step construction! // // History: 08-May-91 BartoszM Created. // //---------------------------------------------------------------------------- // Macro used by Reheap and MakeHeap (for speed) #define REHEAP(CHeap, CItem, LessThan, iroot) \ \ CItem * root_item = _item[iroot]; \ int parent, child; \ for ( parent = iroot, child = 2 * iroot + 1; \ child <= _end; \ parent = child, child = 2 * child + 1 ) \ { \ if ( child < _end \ && LessThan ( _item[child+1], _item[child] ) ) \ child++; \ \ if ( ! LessThan ( _item[child], root_item ) ) \ break; \ \ _item [parent] = _item [child]; \ } \ _item [parent] = root_item; #define REHEAPKEY(CHeap, CItem, LessThan, iroot, GetKey, KeyType) \ \ CItem * root_item = _item[iroot]; \ KeyType root_key; \ if ( -1 != _end ) \ root_key = GetKey( root_item ); \ int parent, child; \ for ( parent = iroot, child = 2 * iroot + 1; \ child <= _end; \ parent = child, child = 2 * child + 1 ) \ { \ if ( child < _end \ && LessThan ( _item[child+1], _item[child] ) ) \ child++; \ \ if ( ! LessThan ( _item[child], root_key ) ) \ break; \ \ _item [parent] = _item [child]; \ } \ _item [parent] = root_item; // // Implementation // #define IMP_HEAP( CHeap, CItem, LessThan ) \ \ CHeap::~CHeap() \ { \ for ( int i = 0; i <= _end; i++ ) \ delete _item[i]; \ delete _item; \ } \ \ CItem * CHeap::RemoveTop () \ { \ if ( IsEmpty() ) \ return 0; \ CItem * ret = Top(); \ if ( _end >= 0 ) \ { \ _item [0] = _item [_end]; \ _item[_end--] = 0; \ Reheap(); \ } \ return ret; \ } \ \ void CHeap::Add ( CItem * item ) \ { \ _end++; \ int child, parent; \ for ( child = _end, parent = (_end-1)/2; \ child > 0; \ child=parent, parent = (parent-1)/2) \ { \ if ( !LessThan( item, _item[parent] )) \ break; \ _item[child] = _item[parent]; \ } \ _item[child] = item; \ } \ \ void CHeap::Reheap () \ { \ REHEAP (CHeap, CItem, LessThan, 0) \ } \ \ void CHeap::MakeHeap() \ { \ for ( int iroot = ((_end+1)/2) - 1; \ iroot >= 0; iroot-- ) \ { \ REHEAP ( CHeap, CItem, LessThan, iroot)\ } \ } #define IMP_HEAP_KEY( CHeap, CItem, LessThan, GetKey, KeyType ) \ \ void CHeap::AddKey ( CItem * item, KeyType key ) \ { \ _end++; \ int child, parent; \ for ( child = _end, parent = (_end-1)/2; \ child > 0; \ child=parent, parent = (parent-1)/2) \ { \ if ( !LessThan( key, _item[parent] )) \ break; \ _item[child] = _item[parent]; \ } \ _item[child] = item; \ } \ \ inline void CHeap::ReheapKey () \ { \ REHEAPKEY (CHeap, CItem, LessThan, 0, GetKey, KeyType ) \ } \ \ CItem * CHeap::RemoveTopKey () \ { \ if ( IsEmpty() ) \ return 0; \ CItem * ret = Top(); \ if ( _end >= 0 ) \ { \ _item [0] = _item [_end]; \ _item[_end--] = 0; \ ReheapKey(); \ } \ return ret; \ } \ \