void heap_heapify_down(heap* h) { unsigned int pos = 0, newpos, temp; node** graph_nodes; graph_nodes = &h->g->nodes; while(1) { if(HEAP_LEFT(pos) <= h->count) { if(HEAP_RIGHT(pos) <= h->count) { newpos = (*h->compare)(h->g, h->nodes[HEAP_RIGHT(pos)], h->nodes[HEAP_LEFT(pos)]) < 0 ? HEAP_RIGHT(pos) : HEAP_LEFT(pos); } else { newpos = HEAP_LEFT(pos); } } else { break; } if((*h->compare)(h->g, h->nodes[pos], h->nodes[newpos]) > 0) { temp = h->nodes[pos]; (*graph_nodes)[temp].heap_index = newpos; (*graph_nodes)[h->nodes[newpos]].heap_index = pos; h->nodes[pos] = h->nodes[newpos]; h->nodes[newpos] = temp; } else { break; /* A posição está correta*/ } } }
static inline void heap_sort_percolate_down(void *base, uint32 size, uint32 csize, uint32 index, sint32 (*compare)(const void *, const void *)) { uint32 i; void *tmp; uint32 child; assert_exit(sort_parameters_legal_p(base, size, csize, compare)); assert_exit(index < size); tmp = memory_cache_allocate(csize); sort_cell_copy(tmp, base + index * csize, csize); i = index; while (HEAP_LEFT(i) < size) { child = HEAP_LEFT(i); if (child != size - 1 && compare(base + child * csize, base + (child + 1) * csize) < 0) { child++; } if (compare(tmp, base + child * csize) < 0) { sort_cell_copy(base + i * csize, base + child * csize, csize); } else { break; } i = child; } sort_cell_copy(base + i * csize, tmp, csize); memory_cache_free(tmp); }
/* * Remove the top element, or object. */ int fr_heap_extract(fr_heap_t *hp, void *data) { int child, parent; int max; if (!hp || (hp->num_elements == 0)) return 0; max = hp->num_elements - 1; /* * Extract element. Default is the first one. */ if (!data) { parent = 0; } else { /* extract from the middle */ if (!hp->offset) return 0; parent = *((int *)(((uint8_t *)data) + hp->offset)); /* * Out of bounds. */ if (parent < 0 || parent >= hp->num_elements) return 0; } RESET_OFFSET(hp, parent); child = HEAP_LEFT(parent); while (child <= max) { /* * Maybe take the right child. */ if ((child != max) && (hp->cmp(hp->p[child + 1], hp->p[child]) < 0)) { child = child + 1; } hp->p[parent] = hp->p[child]; SET_OFFSET(hp, parent); parent = child; child = HEAP_LEFT(child); } hp->num_elements--; /* * We didn't end up at the last element in the heap. * This element has to be re-inserted. */ if (parent != max) { /* * Fill hole with last entry and bubble up, * reusing the insert code */ hp->p[parent] = hp->p[max]; return fr_heap_bubble(hp, parent); } return 1; }
void heap_heapify(heap_t* h, int i) { int l, r; int largest; double tmp; double* tmp_data; // FIXME: void* if (i < h->len/2) { l = HEAP_LEFT(i); r = HEAP_RIGHT(i); if((l < h->len) && (h->A[l] > h->A[i])) largest = l; else largest = i; if((r < h->len) && (h->A[r] > h->A[largest])) largest = r; if(largest != i) { tmp = h->A[i]; tmp_data = h->data[i]; h->A[i] = h->A[largest]; h->data[i] = h->data[largest]; h->A[largest] = tmp; h->data[largest] = tmp_data; heap_heapify(h,largest); } } }
/* * change object position and update references * XXX this one is never used! */ static void heap_move(struct dn_heap *h, uint64_t new_key, void *object) { int temp, i, max = h->elements-1; struct dn_heap_entry *p, buf; if (h->ofs <= 0) panic("cannot move items on this heap"); p = h->p; /* shortcut */ i = *((int *)((char *)object + h->ofs)); if (DN_KEY_LT(new_key, p[i].key) ) { /* must move up */ p[i].key = new_key; for (; i>0 && DN_KEY_LT(new_key, p[(temp = HEAP_FATHER(i))].key); i = temp ) { /* bubble up */ HEAP_SWAP(p[i], p[temp], buf); SET_OFFSET(h, i); } } else { /* must move down */ p[i].key = new_key; while ( (temp = HEAP_LEFT(i)) <= max ) { /* found left child */ if (temp != max && DN_KEY_LT(p[temp+1].key, p[temp].key)) temp++; /* select child with min key */ if (DN_KEY_LT(>p[temp].key, new_key)) { /* go down */ HEAP_SWAP(p[i], p[temp], buf); SET_OFFSET(h, i); } else break; i = temp; } }
static void reheap_down(pj_timer_heap_t *ht, pj_timer_entry *moved_node, size_t slot, size_t child) { PJ_CHECK_STACK(); // Restore the heap property after a deletion. while (child < ht->cur_size) { // Choose the smaller of the two children. if (child + 1 < ht->cur_size && PJ_TIME_VAL_LT(ht->heap[child + 1]->_timer_value, ht->heap[child]->_timer_value)) child++; // Perform a <copy> if the child has a larger timeout value than // the <moved_node>. if (PJ_TIME_VAL_LT(ht->heap[child]->_timer_value, moved_node->_timer_value)) { copy_node( ht, slot, ht->heap[child]); slot = child; child = HEAP_LEFT(child); } else // We've found our location in the heap. break; } copy_node( ht, slot, moved_node); }
/** * @brief CSLR MAX-HEAPIFY * * This routine creates a max-heap for the subtree rooted at index i. The * index is 0 based. * * @param[in] h The heap to operate on * @param[in] i The (0-based) subtree index * @return HEAP_ERR_E */ HEAP_ERR_E heap_max_heapify (HEAP_T* h, unsigned long i) { unsigned long l = HEAP_LEFT(i); unsigned long r = HEAP_RIGHT(i); unsigned long largest; //fprintf (stdout, "i=%lu; l=%lu; r=%lu\n", i, l, r); if (h->type == DS_HEAP_MIN) return HEAP_ERR_WRONG_TYPE; if (l < h->heap_size && (HEAP_KEY(h, l) > HEAP_KEY(h, i))) largest = l; else largest = i; if (r < h->heap_size && (HEAP_KEY(h, r) > HEAP_KEY(h, largest))) largest = r; if (largest != i) { HEAP_SWAP_NODES(i,largest); heap_max_heapify (h, largest); } /* todo: set was_heapified to true */ return HEAP_ERR_OK; }
static void heapify(plane_t *h, uint32 index, uint32 size) { uint32 c; plane_t tmp; for (c = HEAP_LEFT(index); c < (size-1); index = c, c = HEAP_LEFT(index)) { if (h[c].plane.score > h[c+1].plane.score) c++; if (h[index].plane.score > h[c].plane.score) { HEAP_SWAP(h[index], h[c]); } else { return; } } if (c == (size-1) && h[index].plane.score > h[c].plane.score) { HEAP_SWAP(h[index], h[c]); } }
/** * @brief graphviz description plugin for heap ds. * * @param[in] h The heap to operate in * @param[in] filename The file to write the graphviz description to. * @return HEAP_ERR_E */ HEAP_ERR_E heap_graphviz_description ( HEAP_T* h, char* filename ) { FILE* fp; unsigned long idx = 0; unsigned long weight; if (NULL == filename) { fp = stderr; } else { fp = fopen (filename, "w"); if (NULL == fp) return HEAP_ERR_ERR; } fprintf (fp, "graph G {\n"); fprintf (fp, "node [shape = circle, style=filled, color=\"sienna2\"];\n"); fprintf (fp, "size=\"12,8\"\n"); weight = h->heap_size; if (HEAP_LEFT(idx) < h->heap_size) fprintf (fp, "\t%lu -- %lu [headlabel=\"%lu\", weight=%lu];\n ", HEAP_KEY(h, idx), HEAP_KEY(h, HEAP_LEFT(idx)), HEAP_LEFT(idx), weight); if (HEAP_RIGHT(idx) < h->heap_size) fprintf (fp, "\t%lu -- %lu [headlabel=\"%lu\", weight=%lu];\n", HEAP_KEY(h, idx), HEAP_KEY(h, HEAP_RIGHT(idx)), HEAP_RIGHT(idx), weight); for (idx = 1; idx < h->heap_size; idx++) { if (HEAP_LEFT(idx) < h->heap_size) fprintf (fp, "\t%lu -- %lu [headlabel = \"%lu\"]; \n ", HEAP_KEY(h, idx), HEAP_KEY(h, HEAP_LEFT(idx)), HEAP_LEFT(idx)); if (HEAP_RIGHT(idx) < h->heap_size) fprintf (fp, "\t%lu -- %lu [headlabel = \"%lu\"];\n", HEAP_KEY(h, idx), HEAP_KEY(h, HEAP_RIGHT(idx)), HEAP_RIGHT(idx)); } fprintf (fp, "}\n"); if (NULL != filename) fclose (fp); return HEAP_ERR_OK; }
void heap_dump(const heap* h, const unsigned int from) { if(from == 0) { printf("digraph g {\nnode [shape = record,height=.1];\n"); } if(from < h->count) { printf("node%d[ label = \"<f0> | <f1> %s | <f2>\"];\n", from, h->g->nodes[h->nodes[from]].value); if(HEAP_LEFT(from) < h->count) { printf("\"node%d\":f0 -> \"node%d\":f1\n", from, HEAP_LEFT(from)); heap_dump(h, HEAP_LEFT(from)); } if(HEAP_RIGHT(from) < h->count) { printf("\"node%d\":f2 -> \"node%d\":f1\n", from, HEAP_RIGHT(from)); heap_dump(h, HEAP_RIGHT(from)); } } if(from == 0) { printf("}\n"); } }
/* * remove top element from heap, or obj if obj != NULL */ void heap_extract(struct dn_heap *h, void *obj) { int child, father, max = h->elements - 1; if (max < 0) { printf("--- %s: empty heap 0x%p\n", __FUNCTION__, h); return; } if (obj == NULL) father = 0; /* default: move up smallest child */ else { /* extract specific element, index is at offset */ if (h->ofs <= 0) panic("%s: extract from middle not set on %p\n", __FUNCTION__, h); father = *((int *)((char *)obj + h->ofs)); if (father < 0 || father >= h->elements) { panic("%s: father %d out of bound 0..%d\n", __FUNCTION__, father, h->elements); } } /* * below, father is the index of the empty element, which * we replace at each step with the smallest child until we * reach the bottom level. */ // XXX why removing RESET_OFFSET increases runtime by 10% ? RESET_OFFSET(h, father); while ( (child = HEAP_LEFT(father)) <= max ) { if (child != max && DN_KEY_LT(h->p[child+1].key, h->p[child].key) ) child++; /* take right child, otherwise left */ h->p[father] = h->p[child]; SET_OFFSET(h, father); father = child; } h->elements--; if (father != max) { /* * Fill hole with last entry and bubble up, * reusing the insert code */ h->p[father] = h->p[max]; heap_insert(h, father, NULL); } }
static void max_heap_fix_down(int *t, int n, int p) { while (1) { int i = p; int left = HEAP_LEFT(i); int right = HEAP_RIGHT(i); if (left < n && t[i] < t[left]) i = left; if (right < n && t[i] < t[right]) i = right; if (i == p) break; swap_places(t, p, i); p = i; } }
void heap_max_heapify(int *v, int size, int i) { int l, r; int largest; l = HEAP_LEFT(i); r = HEAP_RIGHT(i); if (l < size && v[l] > v[i]) largest = l; else largest = i; if (r < size && v[r] > v[largest]) largest = r; if (largest != i) { swap(v, i, largest); heap_max_heapify(v, size, largest); } }
static void BLI_heap_down(Heap *heap, int i) { while (1) { int size = heap->size, smallest; int l = HEAP_LEFT(i); int r = HEAP_RIGHT(i); smallest = ((l < size) && HEAP_COMPARE(heap->tree[l], heap->tree[i]))? l: i; if ((r < size) && HEAP_COMPARE(heap->tree[r], heap->tree[smallest])) smallest = r; if (smallest == i) break; HEAP_SWAP(heap, i, smallest); i = smallest; } }
static void heap_heapify(struct heap_list *h, int i) { int l, r, largest; void **p; restart: l = HEAP_LEFT(i); r = HEAP_RIGHT(i); p = h->heap_data; if (l < h->heap_keys && (h->heap_comp_fun(p[l], p[i]) > 0)) largest = l; else largest = i; if (r < h->heap_keys && h->heap_comp_fun(p[r], p[largest]) > 0) largest = r; if (largest != i) { heap_exchange(h, i, largest); i = largest; goto restart; } }
static pj_timer_entry * remove_node( pj_timer_heap_t *ht, size_t slot) { pj_timer_entry *removed_node = ht->heap[slot]; // Return this timer id to the freelist. push_freelist( ht, removed_node->_timer_id ); // Decrement the size of the heap by one since we're removing the // "slot"th node. ht->cur_size--; // Set the ID removed_node->_timer_id = -1; // Only try to reheapify if we're not deleting the last entry. if (slot < ht->cur_size) { int parent; pj_timer_entry *moved_node = ht->heap[ht->cur_size]; // Move the end node to the location being removed and update // the corresponding slot in the parallel <timer_ids> array. copy_node( ht, slot, moved_node); // If the <moved_node->time_value_> is great than or equal its // parent it needs be moved down the heap. parent = HEAP_PARENT (slot); if (PJ_TIME_VAL_GTE(moved_node->_timer_value, ht->heap[parent]->_timer_value)) reheap_down( ht, moved_node, slot, HEAP_LEFT(slot)); else reheap_up( ht, moved_node, slot, parent); } return removed_node; }
/** * @brief CSLR MIN-HEAPIFY * * This routine creates a min-heap for the subtree rooted at index i. The * index is 0 based. * * @param[in] h The heap to operate on * @param[in] i The (0-based) subtree index * @return HEAP_ERR_E */ HEAP_ERR_E heap_min_heapify (HEAP_T* h, unsigned long i) { unsigned long l = HEAP_LEFT(i); unsigned long r = HEAP_RIGHT(i); unsigned long smallest; if (h->type == DS_HEAP_MAX) return HEAP_ERR_WRONG_TYPE; if (l < h->heap_size && (HEAP_KEY(h, l) < HEAP_KEY(h, i))) smallest = l; else smallest = i; if (r < h->heap_size && (HEAP_KEY(h, r) < HEAP_KEY(h, smallest))) smallest = r; if (smallest != i) { HEAP_SWAP_NODES(i,smallest); heap_min_heapify (h, smallest); } return HEAP_ERR_OK; }