void heapSort(T a[],int size){ int i; T tmp; for (int i=size/2-1;i>=0;i--) percolateDown(a,i,size);//´´½¨³õʼµÄ¶Ñ for (i=size-1;i>0;--i){ tmp=a[0]; a[0]=a[i]; a[i]=tmp; percolateDown(a,0,i); } }
void * deleteMin(int size, void ** points, LeastPathCompare * cmp, LeastPathCallback * callback) { void * target = points[1]; points[1] = points[size]; callback(points[size], 1); percolateDown(size - 1, points, 1, cmp, callback); return target; }
int removeMin(struct heapStruct *h) { int retval; // We can only remove an element, if one exists in the heap! if (h->size > 0) { // This is where the minimum is stored. retval = h->heaparray[1]; // Copy the last value into this top slot. h->heaparray[1] = h->heaparray[h->size]; // Our heap will have one fewer items. h->size--; // Need to let this value move down to its rightful spot in the heap. percolateDown(h, 1); // Now we can return our value. return retval; } // No value to return, indicate failure with a -1. else return -1; }
void deleteMin(void) { if(isEmpty()) throw UnderflowException(); array[i]=array[currentSize--]; percolateDown(1); }
int heap::deleteMin(std::string * pId, int * pKey, void * ppData) { // Return 1 if heap is empty if (size == 0) { return 1; } // Set optional data parameters node n = data[1]; // Delete item from hash table mapping->remove(n.id); if (pId) { *pId = n.id; } if (pKey) { *pKey = n.key; } if (ppData) { *(static_cast<void **>(ppData)) = n.pData; } // Swap root node with last node and new root down data[1] = data[size--]; mapping->setPointer(data[1].id, &data[1]); percolateDown(1); return 0; }
void Heap::buildHeap(int * characterFreq) { char letters [27] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', ' ' }; Node * entry; for(int i = 0; i < 27; i++) { if(characterFreq[i] != 0) { occupancy++; entry = new Node(characterFreq[i], letters[i]); heap[occupancy] = entry; } } for(int j = occupancy/2-1; j > 0; --j){ percolateDown( j ); } }
int deletepos(int k) { strcpy(h[k].first, h[hsize].first); strcpy(h[k].last, h[hsize].last); hsize--; percolateDown(k); }
// 删除树根,最大值移到最后 static void deleteMax(int *data, int size) { // size--; // swap(&data[0], &data[size]); // percolateDown(data, 0, size); swap2(data, 0, size - 1); // 堆树根与最后一个data[size-1];交换 percolateDown(data, 0, --size); }
void percolateDown(struct heapStruct *h, int index) { int min; // Only try to percolate down internal nodes. if ((2*index+1) <= h->size) { // Find the minimum value of the two children of this node. min = minimum(h->heaparray[2*index], 2*index, h->heaparray[2*index+1], 2*index+1); // If this value is less than the current value, then we need to move // our current value down the heap. if (h->heaparray[index] > h->heaparray[min]) { swap(h, index, min); // This part is recursive and allows us to continue percolating // down the element in question. percolateDown(h, min); } } // Case where our current element has exactly one child, a left child. else if (h->size == 2*index) { // Here we only compare the current item to its only child. // Clearly, no recursive call is needed since the child of this node // is a leaf. if (h->heaparray[index] > h->heaparray[2*index]) swap(h, index, 2*index); } }
void heapify ( Rank n )//Floyd建堆算法 { for ( int i = lastInternal ( n ); inHeap ( n, i ); i-- ) //自底而上,依次 { percolateDown ( n, i ); //下滤各内部节点 } }
void deleteMin(Comparable& minItem) { if(isEmpty()) throw UnderflowException(); minItem=array[1]; array[1]=array[currentSize--]; percolateDown(1); }
void BinaryHeap<Comparable>::deleteMin( ) { if( isEmpty( ) ) throw Underflow( ); array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); }
void percolateEitherWay(int size, void ** points, int index, LeastPathCompare * cmp, LeastPathCallback * callback) { if(index > 1 && cmp(points[index], points[index/2]) < 0) { percolateUp(size, points, index, cmp, callback); } else { percolateDown(size, points, index, cmp, callback); } }
void heap::deleteMin(huffmanNode* minItem) { if(isEmpty()) throw UnderflowException(); minItem = array[1]; array[1] = array[currentSize--]; percolateDown(1); }
// 建立最大堆 static void buildMaxHeap(int *data, int size) { int i; //由于所有树叶无需进行下滤(没有孩子) //所以只对0 - size/2的结点进行下滤即可 for (i = size / 2 - 1; i >= 0; i--) { percolateDown(data, i, size); } }
void BinaryHeap<Comparable>::deleteMax( Comparable & maxItem ) { if( isEmpty( ) ) throw Underflow( ); maxItem = array[ 1 ]; array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); }
void BinaryHeap<Comparable>::deleteMin( int & minItem ) { if( isEmpty( ) ) throw Underflow( ); minItem = cities[ 1 ]->current; array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); }
void BinaryHeap<Comparable>::deleteMin( Comparable & minItem ) { // if( isEmpty( ) ) // throw Underflow( ); minItem = array[ 1 ]; array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); }
void deleteMin( ) { if (isEmpty()) { printf ("#error: deleteMin() called with <pq> empty\n"); return; } pq.array[1] = pq.array[pq.currentSize--]; percolateDown(1); }
// delete minimal from binary heap based on percolateDown(). ElementType deleteMin(BinaryHeap bh) { ElementType* array = bh->array; swap(array[1], array[bh->size]); // &variable means nickname of the variable bh->size-- ; // size-- 在下滤函数执行之前发生. percolateDown(1, bh) ; return array[bh->size+1]; }
// h points to a heap structure that has values inside of it, but isn't yet // organized into a heap and does exactly that. void heapify(struct heapStruct *h) { int i; // We form a heap by just running percolateDown on the first half of the // elements, in reverse order. for (i=h->size/2; i>0; i--) percolateDown(h, i); }
Comparable minHeap<Comparable>::deleteMin() //delete the root of the minheap { Comparable minItem = heapArray[1]; //the first item is the root item heapArray[1] = heapArray[currentSize--]; //decrement the heap // exchanges++; percolateDown(1); //readjust the heap to accomadate for the item removed return minItem; //return the min item }
// delete minimal from binary heap based on percolateDown(). ElementType deleteMin(BinaryHeap bh) { ElementType *data = bh->array; swap(&data[1], &data[bh->size]); // &variable means nickname of the variable bh->size-- ; // size-- occurs prior to percolateDown(). percolateDown(1, bh) ; return data[bh->size+1]; }
Node * Heap::deleteMin() { Node * min = heap[1]; swap( 1, occupancy ); heap[occupancy] = NULL; occupancy--; percolateDown( 1 ); return min; }
void* Heap::extract() { if (size <= 0) { return NULL; } void *tmp = heap[0]; swap(--size, 0); percolateDown(0); return tmp; }
Comparable BinaryHeap<Comparable>::deleteMax( ) { if( isEmpty( ) ) throw Underflow( ); Comparable temp = array[1]; array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); return temp; }
void MSVehicleContainer::pop() { if (isEmpty()) { throw 1; //!!!Underflow( ); } assert(array.size() > 1); array[ 1 ] = array[ currentSize-- ]; percolateDown(1); }
void heapSort( std::vector<Comp> & array){ std::cout<<"ENTERING HEAP SORT"<<std::endl; int N = array.size(); for ( int j = N-1; j > 0; j--){ /*swap the biggest element and the bottom of the heap */ std::cout << "\nSWAP:"<<"arr["<<0<<"]="<<array[0]<<" & "<<"arr["<<j<<"]="<<array[j]<<std::endl; std::swap( array[0], array[j]); percolateDown(array,0,j); } }
POINT* open_del() { if (size == 0) { return NULL; } POINT* min = heap[1]; // Move last element to root and let it percolate down heap[1] = heap[size--]; percolateDown(1); return min; }
void DeleteMin() { if (hsize > 0) { strcpy(h[1].first, h[hsize].first); strcpy(h[1].last, h[hsize].last); hsize--; percolateDown(1); } else return; }