Optimized heapdown function in binary heap and heap sort.

Author: MostafaTwfiq

Algorithms/Sorting/Sources/HeapSort.c

@@ -133,20 +133,17 @@ void heapUp(char *arr, int index, int elemSize, int (*cmp)(const void *, const v
 void heapDown(char *arr, int length, int index, int elemSize, int (*cmp)(const void *, const void *)) {
 
     int fChildIndex = getFirstChildIndex(index), sChildIndex = getSecondChildIndex(index);
-    int targetChildIndex =
-            fChildIndex >= length && sChildIndex >= length // check if leaf node.
-            ? -1
-            : fChildIndex < length && sChildIndex < length // check if the node has two children.
-              ? cmp(arr + fChildIndex * elemSize, arr + sChildIndex * elemSize) > 0 // check for the proper node index.
-                ? fChildIndex
-                : sChildIndex
-              : fChildIndex >= length //the node has only one child, and we want to return that child index.
-                ? sChildIndex
-                : fChildIndex;
-
-    if (targetChildIndex != -1 && cmp(arr + targetChildIndex * elemSize, arr + index * elemSize) > 0) {
-        swap(arr + index * elemSize, arr + targetChildIndex * elemSize, elemSize);
-        heapDown(arr, length, targetChildIndex, elemSize, cmp);
+    int target = index;
+
+    if (fChildIndex < length && cmp(arr + target * elemSize, arr + fChildIndex * elemSize) < 0)
+        target = fChildIndex;
+
+    if (sChildIndex < length && cmp(arr + target * elemSize, arr + sChildIndex * elemSize) < 0)
+        target = sChildIndex;
+
+    if (target != index) {
+        swap(arr + index * elemSize, arr + target * elemSize, elemSize);
+        heapDown(arr, length, target, elemSize, cmp);
     }
 
 }

DataStructure/Trees/Sources/BinaryHeap.c

@@ -103,20 +103,17 @@ void binaryHeapDown(void **arr, int currentIndex, int length, int (*cmp)(const v
 
     int fChildIndex = binaryHeapGetFChildIndex(currentIndex),
     sChildIndex = binaryHeapGetSChildIndex(currentIndex),
-    targetChildIndex = -1;
+    target = currentIndex;
 
-    if (fChildIndex < length || sChildIndex < length) {
+    if (fChildIndex < length && cmp(arr[target], arr[fChildIndex]) < 0)
+        target = fChildIndex;
 
-        if (fChildIndex < length && sChildIndex < length)
-            targetChildIndex = cmp(arr[fChildIndex], arr[sChildIndex]) > 0 ? fChildIndex : sChildIndex;
-        else
-            targetChildIndex = fChildIndex >= length ? sChildIndex : fChildIndex;
+    if (sChildIndex < length && cmp(arr[target], arr[sChildIndex]) < 0)
+        target = sChildIndex;
 
-    }
-
-    if (targetChildIndex != -1 && cmp(arr[targetChildIndex], arr[currentIndex]) > 0) {
-        binaryHeapSwap(arr, currentIndex, targetChildIndex);
-        binaryHeapDown(arr, targetChildIndex, length, cmp);
+    if (target != currentIndex) {
+        binaryHeapSwap(arr, currentIndex, target);
+        binaryHeapDown(arr, target, length, cmp);
     }
 
 }
@@ -260,7 +257,7 @@ void binaryHeapInsertAll(BinaryHeap *heap, void **items, int length) {
         if (items[i] == NULL) {
 #ifdef C_DATASTRUCTURES_ERRORSTESTSTRUCT_H
             ERROR_TEST->errorCode = INVALID_ARG;
-        return;
+            return;
 #else
             fprintf(stderr, INVALID_ARG_MESSAGE, "item pointer", "binary heap data structure");
             exit(INVALID_ARG);