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);
}
}
