src/heap/vieter_heap.c

@@ -4,30 +4,30 @@
 #include <stdlib.h>
 
 struct vieter_heap {
-  vieter_heap_node *tree;
+  vieter_heap_tree *tree;
 };
 
 vieter_heap *vieter_heap_init() { return calloc(1, sizeof(vieter_heap)); }
 
 uint64_t vieter_heap_size(vieter_heap *heap) {
   uint64_t size = 0;
-  vieter_heap_node *tree = heap->tree;
+  vieter_heap_tree *tree = heap->tree;
 
   while (tree != NULL) {
     size |= (uint64_t)1 << tree->order;
 
-    tree = tree->ptr.next_tree;
+    tree = tree->next;
   }
 
   return size;
 }
 
 void vieter_heap_free(vieter_heap *heap) {
-  vieter_heap_node *tree = heap->tree;
+  vieter_heap_tree *tree = heap->tree;
-  vieter_heap_node *next;
+  vieter_heap_tree *next;
 
   while (tree != NULL) {
-    next = tree->ptr.next_tree;
+    next = tree->next;
     vieter_heap_tree_free(tree);
     tree = next;
   }
@@ -37,10 +37,10 @@ void vieter_heap_free(vieter_heap *heap) {
 
 vieter_heap_error vieter_heap_insert(vieter_heap *heap, uint64_t key,
                                      void *data) {
-  vieter_heap_node *new_tree = vieter_heap_node_init();
+  vieter_heap_node *new_node = vieter_heap_node_init();
-  new_tree->key = key;
+  new_node->key = key;
-  new_tree->data = data;
+  new_node->data = data;
-  new_tree->order = 0;
+  vieter_heap_tree *new_tree = vieter_heap_tree_init(new_node, NULL, 0);
 
   if (heap->tree == NULL) {
     heap->tree = new_tree;
@@ -57,15 +57,13 @@ vieter_heap_error vieter_heap_pop(void **out, vieter_heap *heap) {
   }
 
   if (heap->tree->order == 0) {
-    *out = heap->tree->data;
+      *out = heap->tree->root->data;
-    vieter_heap_tree_free(heap->tree);
+      vieter_heap_tree_free(heap->tree);
-    heap->tree = NULL;
+      heap->tree = NULL;
 
-    return vieter_heap_ok;
+      return vieter_heap_ok;
   }
 
-  heap->tree = vieter_heap_tree_pop(out, heap->tree);
-
   return vieter_heap_ok;
 }
 
@@ -74,16 +72,16 @@ vieter_heap_error vieter_heap_peek(void **out, vieter_heap *heap) {
     return vieter_heap_empty;
   }
 
-  vieter_heap_node *tree = heap->tree;
+  vieter_heap_tree *tree = heap->tree;
-  uint64_t smallest_key = tree->key;
+  uint64_t smallest_key = tree->root->key;
-  *out = tree->data;
+  *out = tree->root->data;
 
-  while (tree->ptr.next_tree != NULL) {
+  while (tree->next != NULL) {
-    tree = tree->ptr.next_tree;
+    tree = tree->next;
 
-    if (tree->key < smallest_key) {
+    if (tree->root->key < smallest_key) {
-      smallest_key = tree->key;
+      smallest_key = tree->root->key;
-      *out = tree->data;
+      *out = tree->root->data;
     }
   }
 

src/heap/vieter_heap_tree.c

@@ -6,15 +6,11 @@ vieter_heap_node *vieter_heap_node_init() {
 
 void vieter_heap_node_free(vieter_heap_node *node) { free(node); }
 
-void vieter_heap_tree_free(vieter_heap_node *root) {
+void vieter_heap_tree_free(vieter_heap_tree *tree) {
-  if (root->order == 0) {
-    goto end;
-  }
-
   uint64_t size = 1;
   vieter_heap_node **stack =
-      malloc(((uint64_t)1 << root->order) * sizeof(vieter_heap_node *));
+      malloc(((uint64_t)1 << tree->order) * sizeof(vieter_heap_node *));
-  stack[0] = root->largest_order;
+  stack[0] = tree->root;
 
   vieter_heap_node *node;
 
@@ -27,8 +23,8 @@ void vieter_heap_tree_free(vieter_heap_node *root) {
       size++;
     }
 
-    if (node->ptr.next_largest_order != NULL) {
+    if (node->next_largest_order != NULL) {
-      stack[size] = node->ptr.next_largest_order;
+      stack[size] = node->next_largest_order;
       size++;
     }
 
@@ -36,152 +32,126 @@ void vieter_heap_tree_free(vieter_heap_node *root) {
   }
 
   free(stack);
-
+  free(tree);
-end:
-  vieter_heap_node_free(root);
 }
 
-vieter_heap_node *vieter_heap_tree_merge_same_order(vieter_heap_node *root_a,
+vieter_heap_tree *vieter_heap_tree_init(vieter_heap_node *root,
-                                                    vieter_heap_node *root_b) {
+                                        vieter_heap_tree *next, uint8_t order) {
-  vieter_heap_node *new_root;
+  vieter_heap_tree *tree = malloc(sizeof(vieter_heap_tree));
 
-  if (root_a->key <= root_b->key) {
+  tree->root = root;
-    new_root = root_a;
+  tree->next = next;
-    root_b->ptr.next_largest_order = root_a->largest_order;
+  tree->order = order;
-    root_a->largest_order = root_b;
-  } else {
-    new_root = root_b;
-    root_a->ptr.next_largest_order = root_b->largest_order;
-    root_b->largest_order = root_a;
-  }
 
-  new_root->order++;
+  return tree;
-
-  return new_root;
 }
 
-vieter_heap_node *vieter_heap_tree_merge(vieter_heap_node *root_a,
+void vieter_heap_tree_swap(vieter_heap_tree *t1, vieter_heap_tree *t2) {
-                                         vieter_heap_node *root_b) {
+  vieter_heap_tree temp = {
-  vieter_heap_node *root, *target, *out;
+      .order = t1->order, .root = t1->root, .next = t1->next};
 
-  if (root_a->order <= root_b->order) {
+  t1->order = t2->order;
-    target = root_a;
+  t1->root = t2->root;
-    root = root_b;
+  t1->next = t2->next;
+
+  t2->order = temp.order;
+  t2->root = temp.root;
+  t2->next = temp.next;
+}
+
+vieter_heap_tree *vieter_heap_tree_merge_same_order(vieter_heap_tree *tree_a,
+                                                    vieter_heap_tree *tree_b) {
+  vieter_heap_tree *new_tree;
+
+  if (tree_a->root->key <= tree_b->root->key) {
+    new_tree = tree_a;
+    tree_a->root->next_largest_order = tree_a->root->largest_order;
+    tree_a->root->largest_order = tree_b->root;
+
+    free(tree_b);
   } else {
-    target = root_b;
+    new_tree = tree_b;
-    root = root_a;
+    tree_b->root->next_largest_order = tree_b->root->largest_order;
+    tree_b->root->largest_order = tree_a->root;
+
+    free(tree_a);
   }
 
-  vieter_heap_node *next_tree, *next_target;
+  new_tree->order++;
-  vieter_heap_node *previous_target = NULL;
 
-  while (target != NULL && root != NULL) {
+  return new_tree;
-    if (target->order == root->order) {
+}
-      next_tree = root->ptr.next_tree;
-      next_target = target->ptr.next_tree;
 
-      target = vieter_heap_tree_merge_same_order(target, root);
+vieter_heap_tree *vieter_heap_tree_merge(vieter_heap_tree *tree_a,
+                                         vieter_heap_tree *tree_b) {
+  vieter_heap_tree *tree, *target, *out;
 
-      target->ptr.next_tree = next_target;
+  if (tree_a->order <= tree_b->order) {
+    target = tree_a;
+    tree = tree_b;
+  } else {
+    target = tree_b;
+    tree = tree_a;
+  }
+
+  vieter_heap_tree *next_tree, *next_target;
+  vieter_heap_tree *previous_target = NULL;
+
+  while (target != NULL && tree != NULL) {
+    if (target->order == tree->order) {
+      next_tree = tree->next;
+      next_target = target->next;
+
+      target = vieter_heap_tree_merge_same_order(target, tree);
+
+      target->next = next_target;
 
       // If this merge produces a binomial tree whose size is already in
       // target, it will be the next target. Therefore, we can  merge target's
       // trees until we no longer have a duplicate depth.
-      while (target->ptr.next_tree != NULL &&
+      while (target->next != NULL && target->next->order == target->order) {
-             target->ptr.next_tree->order == target->order) {
+        next_target = target->next->next;
-        next_target = target->ptr.next_tree->ptr.next_tree;
+        target = vieter_heap_tree_merge_same_order(target, target->next);
-        target =
+        target->next = next_target;
-            vieter_heap_tree_merge_same_order(target, target->ptr.next_tree);
-        target->ptr.next_tree = next_target;
       }
 
       if (previous_target != NULL) {
-        previous_target->ptr.next_tree = target;
+        previous_target->next = target;
       } else {
         out = target;
       }
 
-      root = next_tree;
+      tree = next_tree;
-    } else if (target->order > root->order) {
+    } else if (target->order > tree->order) {
-      next_tree = root->ptr.next_tree;
+        next_tree = tree->next;
 
       if (previous_target == NULL) {
-        previous_target = root;
+        previous_target = tree;
-        out = root;
+        out = tree;
       } else {
-        previous_target->ptr.next_tree = root;
+        previous_target->next = tree;
       }
 
-      root->ptr.next_tree = target;
+      tree->next = target;
-      root = next_tree;
+      tree = next_tree;
     } else {
       if (previous_target == NULL) {
         out = target;
       }
 
       previous_target = target;
-      target = target->ptr.next_tree;
+      target = target->next;
     }
   }
 
   // Append final part of tree to target
   if (target == NULL) {
-    previous_target->ptr.next_tree = root;
+    previous_target->next = tree;
   }
 
   return out;
 }
 
-vieter_heap_node *vieter_heap_tree_pop(void **out, vieter_heap_node *tree) {
+vieter_heap_tree *vieter_heap_tree_pop(vieter_heap_tree *tree) {
-  vieter_heap_node *tree_before_smallest = NULL;
-  vieter_heap_node *previous_tree = NULL;
-  vieter_heap_node *original_root = tree;
 
-  uint64_t smallest_key = tree->key;
-
-  while (tree->ptr.next_tree != NULL) {
-    previous_tree = tree;
-    tree = tree->ptr.next_tree;
-
-    if (tree->key < smallest_key) {
-      smallest_key = tree->key;
-      tree_before_smallest = previous_tree;
-    }
-  }
-
-  vieter_heap_node *tree_to_pop;
-
-  if (tree_before_smallest != NULL) {
-    tree_to_pop = tree_before_smallest->ptr.next_tree;
-    tree_before_smallest->ptr.next_tree = tree_to_pop->ptr.next_tree;
-  } else {
-    tree_to_pop = original_root;
-    original_root = original_root->ptr.next_tree;
-  }
-
-  *out = tree_to_pop->data;
-
-  if (tree_to_pop->order == 0) {
-    vieter_heap_tree_free(tree);
-
-    return original_root;
-  }
-
-  previous_tree = tree_to_pop->largest_order;
-  vieter_heap_node_free(tree_to_pop);
-
-  tree = previous_tree->ptr.next_largest_order;
-  previous_tree->ptr.next_tree = NULL;
-
-  vieter_heap_node *next_tree;
-
-  while (tree != NULL) {
-    next_tree = tree->ptr.next_largest_order;
-    tree->ptr.next_tree = previous_tree;
-
-    previous_tree = tree;
-    tree = next_tree;
-  }
-
-  return vieter_heap_tree_merge(original_root, previous_tree);
 }

src/heap/vieter_heap_tree.h

@@ -8,29 +8,31 @@ typedef struct vieter_heap_node {
     uint64_t key;
     void *data;
     struct vieter_heap_node *largest_order;
-    union {
+    struct vieter_heap_node *next_largest_order;
-        struct vieter_heap_node *next_tree;
-        struct vieter_heap_node *next_largest_order;
-    } ptr;
-    uint8_t order;
 } vieter_heap_node;
 
 vieter_heap_node *vieter_heap_node_init();
 
 void vieter_heap_node_free(vieter_heap_node *node);
 
-/* vieter_heap_tree *vieter_heap_tree_init(vieter_heap_node *root, vieter_heap_tree *next, uint8_t order); */
+typedef struct vieter_heap_tree {
+    uint8_t order;
+    vieter_heap_node *root;
+    struct vieter_heap_tree *next;
+} vieter_heap_tree;
+
+vieter_heap_tree *vieter_heap_tree_init(vieter_heap_node *root, vieter_heap_tree *next, uint8_t order);
 
 /*
  * Deallocate a tree object, along with its underlying tree structure.
  */
-void vieter_heap_tree_free(vieter_heap_node *root);
+void vieter_heap_tree_free(vieter_heap_tree *tree);
 
-vieter_heap_node *vieter_heap_tree_merge(vieter_heap_node *root_a, vieter_heap_node *root_b);
+vieter_heap_tree *vieter_heap_tree_merge(vieter_heap_tree *tree_a, vieter_heap_tree *tree_b);
 
-vieter_heap_node *vieter_heap_tree_merge_same_order(vieter_heap_node *root_a,
+vieter_heap_tree *vieter_heap_tree_merge_same_order(vieter_heap_tree *tree_a,
-                                                    vieter_heap_node *root_b);
+                                                    vieter_heap_tree *tree_b);
 
-vieter_heap_node *vieter_heap_tree_pop(void **out, vieter_heap_node *root);
+vieter_heap_tree *vieter_heap_tree_pop(vieter_heap_tree *tree);
 
 #endif

test/heap/test_heap.c

@@ -16,18 +16,18 @@ void test_init() {
 void test_merge_same_order() {
     vieter_heap_node *root_a = vieter_heap_node_init();
     root_a->key = 1;
-    root_a->order = 0;
+    vieter_heap_tree *tree_a = vieter_heap_tree_init(root_a, NULL, 1);
 
     vieter_heap_node *root_b = vieter_heap_node_init();
     root_b->key = 2;
-    root_b->order = 0;
+    vieter_heap_tree *tree_b = vieter_heap_tree_init(root_b, NULL, 1);
 
-    vieter_heap_node *merged = vieter_heap_tree_merge_same_order(root_a, root_b);
+    vieter_heap_tree *merged = vieter_heap_tree_merge_same_order(tree_a, tree_b);
 
-    TEST_CHECK(merged == root_a);
+    TEST_CHECK(merged == tree_a);
-    TEST_CHECK(merged->key == 1);
+    TEST_CHECK(merged->root->key == 1);
-    TEST_CHECK(merged->largest_order == root_b);
+    TEST_CHECK(merged->root->largest_order == root_b);
-    TEST_CHECK(merged->ptr.next_largest_order == NULL);
+    TEST_CHECK(merged->root->next_largest_order == NULL);
 
     vieter_heap_tree_free(merged);
 }
@@ -59,7 +59,7 @@ void test_pop() {
 
     for (uint64_t i = 50; i > 0; i--) {
         vieter_heap_insert(heap, i, (void *)i);
-        TEST_SIZE(heap, (uint64_t)51 - i);
+        TEST_SIZE(heap, (uint64_t)50 - i);
 
         TEST_CHECK(vieter_heap_peek(&data, heap) == vieter_heap_ok);
         TEST_CHECK(data == (void*)i);
@@ -80,6 +80,5 @@ TEST_LIST = {
     {"init", test_init},
     {"merge same order", test_merge_same_order},
     {"insert", test_insert},
-    {"pop", test_pop},
     {NULL, NULL}
 };