static void heapify(binheap_t *h) { uint32_t i; for (i = (h->size + 1) / 2; i; i--) { percolate_down(h, i); } percolate_down(h, 0); }
void heap_sort(Item *arr, int n) { int i; for(i = n/2; i >= 0; --i) { percolate_down(i, arr, n); } for(i = n-1; i > 0; --i) { swap(&arr[0], &arr[i]); percolate_down(0, arr, i); } }
void percolate_down(int i){ int left,right,max=0,temp; if(i<0) return -1; left=left_child(i); right=right_child(i); if(left!=-1 && h->a[left]>h->a[i]) max=left; else max=i; if(right!=-1 && h->a[right]>h->a[max]) max=right; if(max!=i){ //swap elements at max & i temp=h->a[max]; h->a[max]=h->a[i]; h->a[i]=temp; percolate_down(max); } }
int pq_delete_top(PQ* pq, int *id, double *priority) { int pq_size = pq->size; if(pq_size == 0) { printf("Empty priority queue.\n"); return 0; } *id = pq->heap[1].id; *priority = pq->heap[1].priority; if(pq_size > 1) { int new_id = pq->heap[pq_size].id; double new_priority = pq->heap[pq_size].priority; pq->heap[1].id = new_id; pq->heap[1].priority = new_priority; pq->id_ptrs[new_id] = &(pq->heap[1]); } pq->id_ptrs[*id] = NULL; pq->size--; if(pq_size > 1) percolate_down(pq, 1); return 1; }
T pop() const{ T t = nodes.front(); nodes[0] = nodes.back(); nodes.pop_back(); percolate_down(0); return t; }
static roaring_pq_element_t pq_poll(roaring_pq_t *pq) { roaring_pq_element_t ans = *pq->elements; if (pq->size > 1) { pq->elements[0] = pq->elements[--pq->size]; percolate_down(pq, 0); } else --pq->size; // memmove(pq->elements,pq->elements+1,(pq->size-1)*sizeof(roaring_pq_element_t));--pq->size; return ans; }
void BinHeap::update(int positionInHeap) { int parent=(positionInHeap-1)>>1; if(positionInHeap>0 && rtimes[positionInHeap]<rtimes[parent]){ //std::cout << "percolate up" << std::endl; percolate_up(positionInHeap); } else percolate_down(positionInHeap); }
/** * @brief remove element * from queue * * @param[out] q * @param[in] d * * @return */ int pqueue_remove(pqueue_t *q, void *d) { size_t posn = q->getpos(d); q->d[posn] = q->d[--q->size]; if (q->cmppri(q->getpri(d), q->getpri(q->d[posn]))) bubble_up(q, posn); else percolate_down(q, posn); return 0; }
void fill_heap(int p[],int n){ int i; //Create space for allocation all array elements while(n>h->capacity) h=resize_heap(); for(i=0;i<n;i++) h->a[i]=p[i]; h->count=n; //Head to first non-leaf node for(i=(n-2)/2;i>=0;i--) percolate_down(i); }
void *git_pqueue_pop(git_pqueue *q) { void *head; if (!q || q->size == 1) return NULL; head = q->d[1]; q->d[1] = q->d[--q->size]; percolate_down(q, 1); return head; }
void build(heap *h,int array[],int n) { int i; if(h==0) return; while(h->size<n) resize(h); for(i=0;i<n;i++) h->array[i]=array[i]; h->count=n; for(i=(n-1)/2;i>=0;i--) percolate_down(h,i); }
int pqueue_remove(pqueue_t *q, void *d) { unsigned int posn = q->getpos(d); q->d[posn] = q->d[--q->size]; if (q->cmppri(q->getpri(d), q->getpri(q->d[posn]))) { bubble_up(q, posn); } else { percolate_down(q, posn); } return 0; }
int delete_node(heap *h,int i) { int temp; if(!h) { printf("heap is empty\n"); return ; } temp=h->array[i]; h->array[i]=h->array[h->count-1]; h->count--; percolate_down(h,i); return temp; }
void pqueue_change_priority(pqueue_t *q, pqueue_pri_t new_pri, void *d) { size_t posn; pqueue_pri_t old_pri = q->getpri(d); q->setpri(d, new_pri); posn = q->getpos(d); if (q->cmppri(old_pri, new_pri)) bubble_up(q, posn); else percolate_down(q, posn); }
void pqueue_change_priority(pqueue_t *q, pqueue_pri_t new_pri, void *d) { unsigned int posn; pqueue_pri_t old_pri = q->getpri(d); q->setpri(d, new_pri); posn = q->getpos(d); if (q->cmppri(old_pri, new_pri)) { bubble_up(q, posn); } else { percolate_down(q, posn); } }
//Pop root element from heap int pop(){ int temp; if(h->count==0) return -1; temp=h->a[0]; //copy last element at top h->a[0]=h->a[h->count-1]; h->count--; //Heapify percolate_down(0); return temp; }
void * pqueue_pop(pqueue_t *q) { void *head; if (!q || q->size == 1) { return NULL; } head = q->d[1]; q->d[1] = q->d[--q->size]; percolate_down(q, 1); return head; }
static roaring_pq_t *create_pq(const roaring_bitmap_t **arr, uint32_t length) { roaring_pq_t *answer = malloc(sizeof(roaring_pq_t)); answer->elements = malloc(sizeof(roaring_pq_element_t) * length); answer->size = length; for (uint32_t i = 0; i < length; i++) { answer->elements[i].bitmap = (roaring_bitmap_t *) arr[i]; answer->elements[i].is_temporary = false; answer->elements[i].size = roaring_bitmap_portable_size_in_bytes(arr[i]); } for (int32_t i = (length >> 1); i >= 0; i--) { percolate_down(answer, i); } return answer; }
void percolate_down(long long int i) { long long int next; int l=2*i+1; int r=l+1; char temp[100],temp2[100]; if(l-1>top) { return ; } else if(l-1==top) { if(strcmp(array[i].first_name,array[l-1].first_name)<=0 || (strcmp(array[i].first_name,array[l-1].first_name)==0 && strcmp(array[i].last_name,array[l-1].last_name)<=0 )) { return; } else { strcpy(temp2,array[i].last_name); strcpy(array[i].last_name,array[l-1].last_name); strcpy(array[l-1].last_name,temp2); strcpy(temp,array[i].first_name); strcpy(array[i].first_name,array[l-1].first_name); strcpy(array[l-1].first_name,temp); return ; } } else if(strcmp(array[i].first_name,array[min(l,r)].first_name)<=0 || ( strcmp(array[i].first_name,array[min(l,r)].first_name)==0 && strcmp(array[i].last_name,array[min(l,r)].last_name)<=0)) { return ; } else { next=min(l,r); strcpy(temp2,array[i].last_name); strcpy(array[i].last_name,array[next].last_name); strcpy(array[next].last_name,temp2); strcpy(temp,array[i].first_name); strcpy(array[i].first_name,array[next].first_name); strcpy(array[next].first_name,temp); percolate_down(next); } }
void *binheap_remove_min(binheap_t *h) { void *tmp; if (!h->size) { return NULL; } tmp = h->array[0]->datum; free(h->array[0]); h->size--; h->array[0] = h->array[h->size]; percolate_down(h, 0); return tmp; }
static void percolate_down(struct block_pool *bp, size_t node) { size_t child = L(node); struct block tmp; //get the maximum child if (child >= bp->count) return; if (child+1 < bp->count && V(child+1) > V(child)) child++; if (V(child) <= V(node)) return; tmp = bp->block[node]; bp->block[node] = bp->block[child]; bp->block[child] = tmp; percolate_down(bp, child); }
int pq_remove_by_id(PQ* pq, int id) { if(id < 0 || id >= pq->capacity) { printf("ID out of range.\n"); return 0; } if(pq->id_ptrs[id] == NULL) { printf("ID not in use.\n"); return 0; } int pq_size = pq->size; if(pq_size == 0) { printf("Empty priority queue.\n"); return 0; } if(pq_size == 1 || pq->id_ptrs[id]->heap_index == pq_size) { pq->id_ptrs[id] = NULL; // remove the location label pq->size--; return 1; } int new_id; double new_priority; new_id = pq->heap[pq_size].id; // copy data from the last data set new_priority = pq->heap[pq_size].priority; pq->id_ptrs[id]->id = new_id; // replace the data from the id specified pq->id_ptrs[id]->priority = new_priority; pq->id_ptrs[new_id] = pq->id_ptrs[id]; // update the label location of the copied data pq->id_ptrs[id] = NULL; // remove the location label pq->size--; int index = pq->id_ptrs[new_id]->heap_index; percolate_up(pq, index); percolate_down(pq, index); return 1; }
int pq_change_priority(PQ* pq, int id, double new_priority) { if(id < 0 || id >= pq->capacity) { printf("ID out of range.\n"); return 0; } if(pq->id_ptrs[id] == NULL) { printf("ID not in use.\n"); return 0; } pq->id_ptrs[id]->priority = new_priority; int index = pq->id_ptrs[id]->heap_index; percolate_up(pq, index); percolate_down(pq, index); return 1; }
void percolate_down(heap *h,int pos) { int max,temp,left,right; left=leftchild(h,pos); right=rightchild(h,pos); if(left!=-1 && h->array[left]>h->array[pos]) max=left; else max=pos; if(right!=-1 && h->array[right]>h->array[max]) max=right; if(max!=pos) { temp=h->array[max]; h->array[max]=h->array[pos]; h->array[pos]=temp; } else return; percolate_down(h,max); }
void delete_min() { char temp[100],temp2[100]; if(top==0) { printf("-1\n"); } else { printf("%s %s\n",array[1].first_name,array[1].last_name); strcpy(temp2,array[1].last_name); strcpy(array[1].last_name,array[top].last_name); strcpy(array[top].last_name,temp2); strcpy(temp,array[1].first_name); strcpy(array[1].first_name,array[top].first_name); strcpy(array[top].first_name,temp); top--; percolate_down(1); } }
void BinHeap::initializeHeap(double* initialRxnTimes) { /* for(int k=0; k<nRxns; k++) { if(initialRxnTimes[k] != std::numeric_limits<double>::infinity()) std::cout << "inputTimes[" << k << "] = " << initialRxnTimes[k] << ";" << std::endl; else std::cout << "inputTimes[" << k << "] = " << "std::numeric_limits<double>::infinity()" << ";" << std::endl; } */ //set values of whichRxn and heapPosition int i; for(i=0; i<nRxns; i++) { whichRxn[i]=i; heapPosition[i]=i; } //copy input array to rtimes size_t sizeOfRxnTimes=nRxns*sizeof(double); std::memcpy( rtimes, initialRxnTimes, sizeOfRxnTimes ); //order BinHeap for(i=(nRxns-1)>>1; i>=0; i--) { percolate_down(i); } /* std::cout << "\n \n \n "; for(int k=0; k<nRxns; k++) { std::cout << k << "\t" << rtimes[k] << std::endl; } */ }
int heap_remove(heap_t heap, point_t** elem) { if (heap->locked) { return -EBUSY; } heap->locked = 1; point_t* remove = NULL; if (heap->elements > 0) { remove = heap->heap[1].point; heap->heap[1] = heap->heap[heap->elements--]; percolate_down(heap); } if (elem != NULL) { *elem = remove; } heap->locked = 0; return remove != NULL; }
void *block_pool_alloc_align(struct block_pool *bp, size_t size, size_t align) { void *ret; if (align) align--; //if there aren't any blocks, make a new one if (!bp->count) { bp->count = 1; return new_block_tiny(bp->block, size); } //try the root block ret = try_block(bp->block, size, align); if (ret) return ret; //root block is filled, percolate down and try the biggest one percolate_down(bp, 0); ret = try_block(bp->block, size, align); if (ret) return ret; //the biggest wasn't big enough; we need a new block if (bp->count >= bp->alloc) { //make room for another block bp->alloc += bp->alloc; bp->alloc++; bp->block = realloc(bp->block, bp->alloc * sizeof(struct block)); } ret = new_block(bp->block+(bp->count++), size); //fix the heap after adding the new block percolate_up(bp, bp->count-1); return ret; }
void Heap<T>::adjust_to_heap_down(){ int middle = (nodes.size()-1)/2; for(int i = middle; i >= 0; i--){ percolate_down(i); } }