static unsigned bubble_up(heap_t heap, unsigned long i) {
while (i > 1 && heap->cmp(heap_get(heap, parent_node(i)), heap_get(heap, i)) < 0) {
heap_swap(heap, parent_node(i), i);
i = parent_node(i);
}
return i;
}
static inline void max_heapify(struct ast_heap *h, int i)
{
for (;;) {
int l = left_node(i);
int r = right_node(i);
int max;
if (l <= h->cur_len && h->cmp_fn(heap_get(h, l), heap_get(h, i)) > 0) {
max = l;
} else {
max = i;
}
if (r <= h->cur_len && h->cmp_fn(heap_get(h, r), heap_get(h, max)) > 0) {
max = r;
}
if (max == i) {
break;
}
heap_swap(h, i, max);
i = max;
}
}
static void heap_swap(heap_t heap, unsigned long i, unsigned long j) {
void *tmp;
tmp = heap_get(heap, i);
heap_set(heap, i, heap_get(heap, j));
heap_set(heap, j, tmp);
}
static inline void heap_swap(struct ast_heap *h, int i, int j)
{
void *tmp;
tmp = heap_get(h, i);
heap_set(h, i, heap_get(h, j));
heap_set(h, j, tmp);
}
static int bubble_up(struct ast_heap *h, int i)
{
while (i > 1 && h->cmp_fn(heap_get(h, parent_node(i)), heap_get(h, i)) < 0) {
heap_swap(h, i, parent_node(i));
i = parent_node(i);
}
return i;
}
static void *_heap_remove(heap_t heap, unsigned long i) {
void *ret;
if (i > heap->curr)
return NULL;
ret = heap_get(heap, i);
heap_set(heap, i, heap_get(heap, heap->curr--));
i = bubble_up(heap, i);
max_heapify(heap, i);
return ret;
}
static void max_heapify(heap_t heap, unsigned long i) {
for (;;) {
unsigned long l = left_node(i), r = right_node(i), max;
max = l <= heap->curr && heap->cmp(heap_get(heap, l), heap_get(heap, i)) > 0
? l : i;
if (r <= heap->curr && heap->cmp(heap_get(heap, r), heap_get(heap, max)) > 0)
max = r;
if (max == i)
break;
heap_swap(heap, i, max);
i = max;
}
}
static void *_ast_heap_remove(struct ast_heap *h, unsigned int index)
{
void *ret;
if (!index || index > h->cur_len) {
return NULL;
}
ret = heap_get(h, index);
heap_set(h, index, heap_get(h, (h->cur_len)--));
index = bubble_up(h, index);
max_heapify(h, index);
return ret;
}
void *heap_peek(heap_t heap, unsigned long index) {
if (heap == NULL)
return NULL;
if (heap->curr == 0 || index == 0 || index > heap->curr)
return NULL;
return heap_get(heap, index);
}
void test_heapify(void) {
size_t i;
/* initialize data */
int *array = zmalloc(sizeof(int) * LOTS_OF_INTS);
int sum = 0;
for (i = 0; i < LOTS_OF_INTS; i++) {
array[i] = random() % 123456789;
sum += array[i];
}
/* construct a heap from our random array */
heap_t *h = heap_heapify(array, LOTS_OF_INTS, sizeof(int),
NULL, (cmp_func_t)intcmp);
assert(heap_size(h) == LOTS_OF_INTS);
int ctrlsum = 0, maxctrl, *e;
/* peek head */
if (heap_size(h)) maxctrl = *(int*)heap_get(h, 0);
while (heap_size(h)) {
e = heap_pop(h); ctrlsum += *e;
/* check that elements are in heap order */
assert(*e <= maxctrl); maxctrl = *e;
}
assert(ctrlsum == sum);
heap_destroy(h);
free(array);
}
/* get the best cell from the heap */
static void TCOD_path_get_cell(TCOD_path_data_t *path, int *x, int *y, float *distance) {
uint32 offset = heap_get(path,path->heap);
*x=(offset % path->w);
*y=(offset / path->w);
*distance=path->grid[offset];
//printf ("get cell : %d %d %g\n",*x,*y,*distance);
}
void generate_test_heap(void) {
size_t n = 0, i, j;
int sum = 0, *e=NULL;
heap_t *h = heap_init(free, (cmp_func_t)intcmp);
for (i = 0; i < 1000; i++) {
switch (random() % 3) {
case 0:
case 2:
e = zmalloc(sizeof(int)); *e = random() % 123456789;
n++; sum += *e;
heap_insert(h, e);
break;
case 1:
e = heap_pop(h);
if (e) { n--; sum -= *e; free(e); }
break;
}
/* check propper auto resize */
assert(heap_capacity(h) >= heap_size(h));
for (j = 0; j < heap_size(h); j++) {
size_t left = heap_child_l(j);
size_t right = heap_child_r(j);
size_t greatest = heap_greatest_child(h, j);
/* check for heap order is preserved and greatest child is correct */
if (heap_size(h) > right) {
assert(*(int*)heap_get(h, j) >= *(int*)heap_get(h, right));
assert(*(int*)heap_get(h, greatest) >= *(int*)heap_get(h, right));
}
if (heap_size(h) > left) {
assert(*(int*)heap_get(h, j) >= *(int*)heap_get(h, left));
assert(*(int*)heap_get(h, greatest) >= *(int*)heap_get(h, left));
}
}
}
assert(heap_size(h) == n);
int ctrlsum = 0, maxctrl;
if (heap_size(h)) maxctrl = *(int*)heap_get(h, 0);
while (heap_size(h)) {
e = heap_pop(h); ctrlsum += *e;
/* check that elements are in heap order */
assert(*e <= maxctrl); maxctrl = *e;
free(e);
}
assert(ctrlsum == sum);
heap_destroy(h);
}
void *ast_heap_peek(struct ast_heap *h, unsigned int index)
{
if (!h->cur_len || !index || index > h->cur_len) {
return NULL;
}
return heap_get(h, index);
}
// will use vector_set rather than remove and insert for effieciency reasons.
VALUE_TYPE extractMinHeapMinimum(Heap *heap){
HeapNode* top = vector_get(0, heap->vector);
vector_set(0, heap_get(heap->size-1, heap), heap->vector);
vector_removeIndex(heap->size-1, heap->vector);
heap->size--;
heap_minHeapify(0, heap);
return top->value;
}
static void __test_head_add_gt(struct heap *h, uint32_t v) {
if( !heap_full(h) ) {
heap_add(h, &v);
} else {
uint32_t *min = heap_get(h);
if( *min < v ) {
heap_pop(h);
heap_add(h, &v);
}
}
}
void heap_bubble_up(Heap* heap, int index) {
if(index == 0) {
return;
}
int compare = heap->comparator(heap_get(heap, index), heap_parent(heap, index));
if(compare <= 0) {
heap_swap(heap, index, heap_parent_index(index));
heap_bubble_up(heap, heap_parent_index(index));
}
}
void test_heap_test_4(void) {
size_t memsize = heap_mem_size(1, sizeof(struct cw));
fprintf(stderr, "memsize: %ld\n", memsize);
char heap_mem[heap_mem_size(1, sizeof(struct cw))];
struct heap *h = heap_create( heap_mem
, sizeof(heap_mem)
, sizeof(struct cw)
, __cw_leq
, __cw_cpy );
fprintf(stderr, "heap: %p\n", h);
fprintf(stdout, "# heap_size: %ld\n", heap_size(h));
struct cw cats[] = { { 1, 1 }
, { 2, 1 }
, { 1, 2 }
, { 3, 1 }
, { 12, 3 }
, { 5, 1 }
, { 31, 2 }
, { 6, 2 }
, { 7, 1 }
, { 7, 1 }
, { 10, 5 }
};
fprintf(stdout, "\n");
size_t i = 0;
for(; i < sizeof(cats)/sizeof(cats[0]); i++ ) {
fprintf(stdout, "# {%d, %d}\n", cats[i].cat, cats[i].weight);
if( heap_full(h) ) {
struct cw *min = heap_get(h);
if( __cw_leq(min, &cats[i]) ) {
heap_pop(h);
}
}
heap_add(h, &cats[i]);
}
fprintf(stdout, "\nheap_items %ld\n", heap_items(h));
fprintf(stdout, "\n");
while( !heap_empty(h) ) {
struct cw *c = heap_pop(h);
fprintf(stdout, "# {%d, %d}\n", c->cat, c->weight);
}
}
void heap_bubble_down(Heap* heap, int index) {
if(heap_left_child_index(index) <= heap_last_index(heap)) {
int left_compare = heap->comparator(heap_get(heap, index), heap_left_child(heap, index));
if(1 == left_compare) {
heap_swap(heap, index, heap_left_child_index(index));
heap_bubble_down(heap, heap_left_child_index(index));
return;
}
}
if(heap_right_child_index(index) <= heap_last_index(heap)) {
int right_compare = heap->comparator(heap_get(heap, index), heap_right_child(heap, index));
if(1 == right_compare) {
heap_swap(heap, index, heap_right_child_index(index));
heap_bubble_down(heap, heap_right_child_index(index));
return;
}
}
return;
}
int hb_write(buffer_t * hb, void * data, int priority){
assert(hb->type == HEAP_BUFFER);
if(rb_available(hb) > 0){
heap_node_t * n = (heap_node_t*)heap_get(hb, hb->used);
n->priority = priority;
memmove(n->value, data, hb->size - sizeof(int));
int i = hb->used;
hb->used++;
while(i > 0){
int j = (i - 1)/2;
heap_node_t * pn = (heap_node_t*)heap_get(hb, j);
if(n->priority > pn->priority){
__hb_swap(hb, n, pn);
i = j;
n = pn;
}else
break;
}
return 1;
}
return 0;
}
int ast_heap_push(struct ast_heap *h, void *elm)
#endif
{
int i;
if (h->cur_len == h->avail_len && grow_heap(h
#ifdef MALLOC_DEBUG
, file, lineno, func
#endif
)) {
return -1;
}
heap_set(h, ++(h->cur_len), elm);
for (i = h->cur_len;
i > 1 && h->cmp_fn(heap_get(h, parent_node(i)), heap_get(h, i)) < 0;
i = parent_node(i)) {
heap_swap(h, i, parent_node(i));
}
return 0;
}
int ast_heap_verify(struct ast_heap *h)
{
unsigned int i;
for (i = 1; i <= (h->cur_len / 2); i++) {
int l = left_node(i);
int r = right_node(i);
if (l <= h->cur_len) {
if (h->cmp_fn(heap_get(h, i), heap_get(h, l)) < 0) {
return -1;
}
}
if (r <= h->cur_len) {
if (h->cmp_fn(heap_get(h, i), heap_get(h, r)) < 0) {
return -1;
}
}
}
return 0;
}
void add_dictionary_entry(){
char *verb;
word_t words;
verb = (stack_pop(&data_stack)).char_ptr;
words = stack_pop(&data_stack);
//printf("adding %s\n",verb);
int l = strlen(verb);
char* chars = (char *)heap_get(l+1);
strcpy(chars,verb);
int index = hash(verb) % 100;
while(dictionary[index].verb != NULL && strcmp(dictionary[index].verb,verb) ){
index++;
if(index == 100) index = 0;
}
dictionary[index].verb = chars;
dictionary[index].words = words.ptr;
}
int hb_take(buffer_t * hb, void * data){
assert(hb->type == HEAP_BUFFER);
if(rb_has_next(hb) > 0){
heap_node_t * n = (heap_node_t*)heap_get(hb, 0);
memmove(data, n->value, hb->size - sizeof(int));
hb->used--;
heap_node_t * ln = (heap_node_t*)heap_get(hb, hb->used);
__hb_swap(hb, ln, n);
unsigned int i = 0;
while(1){
unsigned int j = 2*i + 1;
unsigned int k = 2*i + 2;
heap_node_t * sn;
if(j < hb->used && k < hb->used){
int pj, pk;
pj = *(int*)heap_get(hb, j);
pk = *(int*)heap_get(hb, k);
if(pj > pk){
sn = (heap_node_t*)heap_get(hb, j);
i = j;
}else{
sn = (heap_node_t*)heap_get(hb, k);
i = k;
}
}else if(j < hb->used){
sn = (heap_node_t*)heap_get(hb, j);
i = j;
}else if (k < hb->used){
sn = (heap_node_t*)heap_get(hb, k);
i = k;
}else
break;
if(n->priority < sn->priority){
__hb_swap(hb, n, sn);
n = sn;
}else
break;
}
return 1;
}
return 0;
}
int heap_next (char **key,
DESCR **data)
{
int
rc = HEAP_OK;
char
*file_name = NULL,
*temp_key;
ASSERT (key);
if ((! file_list)
|| (! file_info))
return HEAP_DATA_NOT_FOUND;
if (file_info == (FILEINFO *) file_list)
{
free_dir_list (file_list);
file_list = NULL;
file_info = NULL;
return HEAP_DATA_NOT_FOUND;
}
file_name = file_info-> dir. file_name;
file_info = file_info-> next;
temp_key = mem_strdup (file_name);
rc = heap_get (temp_key, data);
if (rc)
mem_free (temp_key);
else
*key = temp_key;
return rc;
}
void* heap_parent(Heap* heap, unsigned int index) {
return heap_get(heap, heap_parent_index(index));
}
/* get the best cell from the heap */
static void TCOD_path_get_cell(TCOD_path_data_t *path, int *x, int *y, float *distance) {
uint32 offset = heap_get(path,path->heap);
*x=(offset % path->w);
*y=(offset / path->w);
*distance=path->grid[offset];
}
void* heap_min(Heap* heap) {
return heap_get(heap, 0);
}
void* heap_right_child(Heap* heap, unsigned int index) {
return heap_get(heap, heap_right_child_index(index));
}
void* heap_last(Heap* heap) {
return heap_get(heap, heap_last_index(heap));
}
void heap_swap(Heap* heap, int index0, int index1) {
void* temp = heap_get(heap, index0);
heap_set(heap, index0, heap_get(heap, index1));
heap_set(heap, index1, temp);
}
