Looks like removing top works.

current/algorithms/heap_binomial.c

@@ -1,3 +1,4 @@
+#include <limits.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -111,40 +112,99 @@ void dump_heap(list *q) {
   }
 }
 
-list* node_add(list *q, long key) {
+list* node_union(list *q, node *b) {
-  list *c = NULL;
+  list *bl,*a = q, *c;
-  list *a = q;
-  node *b = node_create(key);
-  list *bl;
 
   if (!q) {
-    a = (list*)malloc(sizeof(list));
+    bl = (list*)malloc(sizeof(list));
-    a->node = b;
+    bl->node = b;
-    return a;
+    return bl;
   }
 
+  int added = 0;
+  bl = a;
   while (a) {
     if (a->node->lvl > b->lvl) { // it a always will be bigger or equal
       list *el = (list*)malloc(sizeof(list));
       el->node = b;
       el->next = a;
       return el;
-    } else {
+    } if (a->node->lvl == b->lvl) {
-      c = a->next;
       a->node = node_union_same_lvl(a->node, b);
       bl = a;
       b = a->node;
-      a = c;
+      a = a->next;
+      added++;
+    } else {
+      bl = a;
+      a = a->next;
     }
   }
 
-  return bl;
+  if (!added) {
+    list *el = (list*)malloc(sizeof(list));
+    el->node = b;
+    el->next = NULL;
+    bl->next = el;
+    return q;
+  } else {
+    return bl;
+  }
 
 }
 
-int node_del(node *q) {
+list* node_add(list *q, long key) {
-  // TODO
+  node *b = node_create(key);
-  return -1;
+
+  return node_union(q, b);
+}
+
+int node_del(list **q) {
+  list *t = *q;
+  long maxValue = INT_MIN;
+  node *maxTree = NULL;
+  
+  while (t) {
+    if (!maxTree || t->node->key > maxValue) {
+      maxValue = t->node->key;
+      maxTree = t->node;
+    }
+
+    t = t->next;
+  }
+
+  // we have max element and tree now
+
+  t = *q;
+
+  if (t->node == maxTree) {
+    printf("Removed maxtree is the beginning\n");
+    t = t->next;
+  } else {
+    printf("Removed maxtree is not the beginning\n");
+    while (t && t->next && t->next->node != maxTree) {
+      t = t->next;
+    }
+
+    t->next = t->next->next;
+  }
+
+  printf("New list pointer 0x%x\n", t);
+
+  // we removed the maxTree from the list
+
+  node *c = maxTree->child;
+  node *b;
+  while (c) {
+    b = c->right;
+    c->right = NULL;
+    t = node_union(t, c);
+    c = b;
+  }
+
+  *q = t;
+  
+  return maxValue;
 }
 
 
@@ -175,8 +235,9 @@ int main() {
         fprintf(stderr, "There is nothing to delete - heap is empty\n");
         continue;
       }
-      // TODO: long key = node_del(q);
+      
-      // printf("Removed element: %d\n", key);
+      long key = node_del(&q);
+      printf("Removed element: %d\n", key);
     } else {
       // handle unknown command
       fprintf(stderr, "Got unknown command %s\n", cmd);

current/algorithms/hoare.c

@@ -0,0 +1,120 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+int hoare(int* arr, int i, int j, int idx) {
+  printf("I: %d, J: %d, IDX: %d\n", i, j, idx);
+  if (idx < i) {
+    return 0xdeadbeef;
+  }
+
+  if (idx > j) {
+    return 0xdeadbeef;
+  }
+
+  int v;
+  int x1,x2;
+  int t;
+  while (i < j - 1) {
+    v = arr[(i + j) / 2];
+    printf("Round: (%d,%d) - v: %d\n", i, j, v);
+    // sorting on three partitions
+
+    x1 = i;
+    x2 = j;
+
+    while (x1 < x2) {
+
+      while (x1 < x2 && arr[x1] <= v) { 
+        printf("x1: %d, arr[x1]: %d\n", x1, arr[x1]);
+        x1++;
+      }
+
+      while (x1 < x2 && arr[x2] >  v) { 
+        printf("x2: %d, arr[x2]: %d\n", x2, arr[x2]);
+        x2--;
+      }
+
+      printf("X1 %d to swap %d\n", x1, arr[x1]);
+      printf("X2 %d to swap %d\n", x2, arr[x2]);
+
+      // if x1 == x2, the change makes no difference
+
+      t = arr[x1];
+      arr[x1] = arr[x2];
+      arr[x2] = t;
+
+    }
+
+    if (arr[x1] > v) x1--; // we could cross == element by
+
+    x2 = x1;
+    x1 = i;
+
+    while (x1 < x2) {
+
+      while (x1 < x2 && arr[x1] < v) { 
+        printf("x1: %d, arr[x1]: %d\n", x1, arr[x1]);
+        x1++;
+      }
+
+      while (x1 < x2 && arr[x2] == v) { 
+        printf("x2: %d, arr[x2]: %d\n", x2, arr[x2]);
+        x2--;
+      }
+
+      printf("X1 %d to swap %d\n", x1, arr[x1]);
+      printf("X2 %d to swap %d\n", x2, arr[x2]);
+
+      // if x1 == x2, the change makes no difference
+
+      t = arr[x1];
+      arr[x1] = arr[x2];
+      arr[x2] = t;
+
+    }
+
+    if (x1 > idx) {
+      printf("Changing j %d to %d\n", j, x1);
+      j = x1;
+    } else {
+      // x1 <= idx
+      printf("Changing i %d to %d\n", i, x1);
+      i = x1;
+    }
+  }
+
+  // we should have i == j == idx
+  printf("i: %d, j: %d, idx: %d, v: %d\n", i, j, idx, arr[idx]);
+  return arr[idx]; // in order to make it work, we need to make sure that in this place is fully sorted, one way is to split into three pieces
+}
+
+/**
+ * n: 4
+ * 4
+ * 3
+ * 2
+ * 1
+ * idx: 4, 3, 2, 1 all work
+ */
+
+int main() {
+
+  int n;
+  printf("Provide n: ");
+  scanf("%d", &n);
+
+  int numbers[n];
+
+  for (int i = 0; i < n; i++) {
+    scanf("%d", &numbers[i]);
+  }
+
+  int idx;
+  printf("Idx: ");
+  scanf("%d", &idx);
+
+  int res = hoare(numbers, 0, n-1, idx);
+  printf("Res: %x\n", res);
+  return 0;
+}