New Vector_sort function, replacing insertion and quick sort

Introduce the new Vector_sort() function and obsolete the old
Vector_quickSort() and Vector_insertionSort() APIs.

This new sort function is a natural, in-place merge sort. I.e. it takes
advantage of partially sorted data, and it's stable.

Space complexity: O(log(n)) worst case (on stack, no malloc())
Time complexity: O(n) best case, O(n*(log(n))^2) average & worst case

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>

Author: Explorer09

Action.c

@@ -542,7 +542,7 @@ static Htop_Reaction actionFilterByUser(State* st) {
    Panel_setHeader(usersPanel, "Show processes of:");
    Machine* host = st->host;
    UsersTable_foreach(host->usersTable, addUserToVector, usersPanel);
-   Vector_insertionSort(usersPanel->items, NULL, usersPanel);
+   Vector_sort(usersPanel->items, NULL, usersPanel);
    ListItem* allUsers = ListItem_new("All users", -1);
    Panel_insert(usersPanel, 0, (Object*) allUsers);
    const ListItem* picked = (ListItem*) Action_pickFromVector(st, usersPanel, 19, false);

EnvScreen.c

@@ -52,8 +52,8 @@ static void EnvScreen_scan(InfoScreen* this) {
       InfoScreen_addLine(this, "Could not read process environment.");
    }
 
-   Vector_insertionSort(this->lines, NULL, this);
-   Vector_insertionSort(panel->items, NULL, this);
+   Vector_sort(this->lines, NULL, this);
+   Vector_sort(panel->items, NULL, this);
    Panel_setSelected(panel, idx);
 }
 

Makefile.am

@@ -90,7 +90,8 @@ myhtopsources = \
 	UptimeMeter.c \
 	UsersTable.c \
 	Vector.c \
-	XUtils.c
+	XUtils.c \
+	generic/sort.c
 
 myhtopheaders = \
 	Action.h \
@@ -163,7 +164,8 @@ myhtopheaders = \
 	UptimeMeter.h \
 	UsersTable.h \
 	Vector.h \
-	XUtils.h
+	XUtils.h \
+	generic/sort.h
 
 # Linux
 # -----

OpenFilesScreen.c

@@ -300,8 +300,8 @@ static void OpenFilesScreen_scan(InfoScreen* super) {
       OpenFiles_Data_clear(&pdata->data);
    }
    free(pdata);
-   Vector_insertionSort(super->lines, NULL, super);
-   Vector_insertionSort(panel->items, NULL, super);
+   Vector_sort(super->lines, NULL, super);
+   Vector_sort(panel->items, NULL, super);
    Panel_setSelected(panel, idx);
 }
 

ProcessLocksScreen.c

@@ -91,8 +91,8 @@ static void ProcessLocksScreen_scan(InfoScreen* this) {
       }
    }
    free(pdata);
-   Vector_insertionSort(this->lines, NULL, this);
-   Vector_insertionSort(panel->items, NULL, this);
+   Vector_sort(this->lines, NULL, this);
+   Vector_sort(panel->items, NULL, this);
    Panel_setSelected(panel, idx);
 }
 

Table.c

@@ -168,7 +168,7 @@ static void Table_buildTree(Table* this) {
    }
 
    // Sort by known parent (roots first), then row ID
-   Vector_quickSort(this->rows, compareRowByKnownParentThenNatural, this);
+   Vector_sort(this->rows, compareRowByKnownParentThenNatural, this);
 
    // Find all processes whose parent is not visible
    for (int i = 0; i < vsize; i++) {
@@ -199,7 +199,7 @@ void Table_updateDisplayList(Table* this) {
          Table_buildTree(this);
    } else {
       if (this->needsSort)
-         Vector_insertionSort(this->rows, NULL, this);
+         Vector_sort(this->rows, NULL, this);
       Vector_prune(this->displayList);
       int size = Vector_size(this->rows);
       for (int i = 0; i < size; i++)

Vector.c

@@ -10,12 +10,19 @@ in the source distribution for its full text.
 #include "Vector.h"
 
 #include <assert.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "XUtils.h"
+#include "generic/sort.h"
 
 
+typedef struct VectorSortContext_ {
+   Object_Compare compare;
+   void* compareContext;
+} VectorSortContext;
+
 Vector* Vector_new(const ObjectClass* type, bool owner, int size) {
    Vector* this;
 
@@ -93,97 +100,24 @@ void Vector_prune(Vector* this) {
    memset(this->array, '\0', this->arraySize * sizeof(Object*));
 }
 
-//static int comparisons = 0;
-
-static void swap(Object** array, int indexA, int indexB) {
-   assert(indexA >= 0);
-   assert(indexB >= 0);
-   Object* tmp = array[indexA];
-   array[indexA] = array[indexB];
-   array[indexB] = tmp;
-}
-
-static int partition(Object** array, int left, int right, int pivotIndex, Object_Compare compare, void* context) {
-   const Object* pivotValue = array[pivotIndex];
-   swap(array, pivotIndex, right);
-   int storeIndex = left;
-   for (int i = left; i < right; i++) {
-      //comparisons++;
-      if (compare(array[i], pivotValue, context) <= 0) {
-         swap(array, i, storeIndex);
-         storeIndex++;
-      }
-   }
-   swap(array, storeIndex, right);
-   return storeIndex;
-}
-
-static void quickSort(Object** array, int left, int right, Object_Compare compare, void* context) {
-   if (left >= right)
-      return;
-
-   int pivotIndex = left + (right - left) / 2;
-   int pivotNewIndex = partition(array, left, right, pivotIndex, compare, context);
-   quickSort(array, left, pivotNewIndex - 1, compare, context);
-   quickSort(array, pivotNewIndex + 1, right, compare, context);
-}
-
-// If I were to use only one sorting algorithm for both cases, it would probably be this one:
-/*
-
-static void combSort(Object** array, int left, int right, Object_Compare compare, void* context) {
-   int gap = right - left;
-   bool swapped = true;
-   while ((gap > 1) || swapped) {
-      if (gap > 1) {
-         gap = (int)((double)gap / 1.247330950103979);
-      }
-      swapped = false;
-      for (int i = left; gap + i <= right; i++) {
-         comparisons++;
-         if (compare(array[i], array[i+gap], context) > 0) {
-            swap(array, i, i+gap);
-            swapped = true;
-         }
-      }
-   }
-}
-
-*/
+ATTR_NONNULL
+static int Vector_sortCompare(const void* p1, const void* p2, void* context) {
+   VectorSortContext* vc = (VectorSortContext*) context;
 
-static void insertionSort(Object** array, int left, int right, Object_Compare compare, void* context) {
-   for (int i = left + 1; i <= right; i++) {
-      Object* t = array[i];
-      int j = i - 1;
-      while (j >= left) {
-         //comparisons++;
-         if (compare(array[j], t, context) <= 0)
-            break;
-
-         array[j + 1] = array[j];
-         j--;
-      }
-      array[j + 1] = t;
-   }
+   return vc->compare(*(const void* const*)p1, *(const void* const*)p2, vc->compareContext);
 }
 
-void Vector_quickSort(Vector* this, Object_Compare compare, void* context) {
-   if (!compare) {
-      assert(this->type->compare);
-      compare = this->type->compare;
-   }
-   assert(Vector_isConsistent(this));
-   quickSort(this->array, 0, this->items - 1, compare, context);
+ATTR_NONNULL_N(1)
+void Vector_sort(Vector* this, Object_Compare compare, void* context) {
+   VectorSortContext vc = {
+      .compare = compare ? compare : this->type->compare,
+      .compareContext = context ? context : this,
+   };
+   assert(vc.compare);
    assert(Vector_isConsistent(this));
-}
 
-void Vector_insertionSort(Vector* this, Object_Compare compare, void* context) {
-   if (!compare) {
-      assert(this->type->compare);
-      compare = this->type->compare;
-   }
-   assert(Vector_isConsistent(this));
-   insertionSort(this->array, 0, this->items - 1, compare, context);
+   Generic_sort(this->array, this->items, sizeof(*this->array), Vector_sortCompare, &vc);
+
    assert(Vector_isConsistent(this));
 }
 

Vector.h

@@ -35,9 +35,7 @@ void Vector_delete(Vector* this);
 
 void Vector_prune(Vector* this);
 
-void Vector_quickSort(Vector* this, Object_Compare compare, void* context);
-
-void Vector_insertionSort(Vector* this, Object_Compare compare, void* context);
+void Vector_sort(Vector* this, Object_Compare compare, void* context);
 
 void Vector_insert(Vector* this, int idx, void* data_);
 

generic/sort.c

@@ -0,0 +1,163 @@
+/*
+htop - generic/sort.c
+(C) 2025 htop dev team
+Released under the GNU GPLv2+, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "config.h" // IWYU pragma: keep
+
+#include "generic/sort.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h> // IWYU pragma: keep
+
+typedef struct MergeSortContext_ {
+   /* To minimize code size, the most frequently referenced member of this
+      structure is ordered first. */
+   size_t elementSize;
+   Object_Compare compare;
+   void* compareContext;
+   void* array;
+} MergeSortContext;
+
+static void swapByte(char* p1, char* p2) {
+   char temp = *p1;
+   *p1 = *p2;
+   *p2 = temp;
+}
+
+static void mergeRuns(MergeSortContext* mctx, void* start, void* mid, const void* end) {
+   size_t* size = &mctx->elementSize;
+
+   assert(*size > 0);
+   assert(mid < start || (size_t)((char*)mid - (char*)start) % *size == 0);
+   assert(end < mid || (size_t)((const char*)end - (char*)mid) % *size == 0);
+
+   size_t rotateSize = 0;
+   while (true) {
+      char* p2 = (char*)mid + rotateSize;
+      if (p2 >= (const char*)end)
+         break;
+
+      char* p1 = (char*)mid - rotateSize;
+      if (p1 <= (char*)start)
+         break;
+      p1 -= *size;
+
+      if (mctx->compare(p1, p2, mctx->compareContext) <= 0)
+         break;
+
+      rotateSize += *size;
+   }
+
+   if (rotateSize == 0)
+      return;
+
+   char* p1 = mid;
+   do {
+      p1 -= 1;
+      swapByte(p1, p1 + rotateSize);
+   } while (p1 + rotateSize > (char*)mid);
+
+   size_t rightSize = (size_t)((const char*)end - (char*)mid);
+
+   void* newStart;
+   void* newMid;
+   const void* newEnd;
+   if ((char*)mid <= (char*)start + rightSize) {
+      newStart = start;
+      newMid = (char*)mid - rotateSize;
+      newEnd = mid;
+      start = mid;
+      mid = (char*)mid + rotateSize;
+   } else {
+      newStart = mid;
+      newMid = (char*)mid + rotateSize;
+      newEnd = end;
+      end = mid;
+      mid = (char*)mid - rotateSize;
+   }
+   mergeRuns(mctx, newStart, newMid, newEnd);
+   mergeRuns(mctx, start, mid, end);
+}
+
+static void* mergeSortSubarray(MergeSortContext* mctx, size_t nextWindowSize, void* windowStart, void* windowEnd) {
+   size_t* size = &mctx->elementSize;
+   void** array = &mctx->array;
+
+   assert(*size > 0);
+   assert(windowStart >= *array);
+   assert((size_t)((char*)windowStart - (char*)*array) % *size == 0);
+   assert(windowEnd >= windowStart);
+   assert((size_t)((char*)windowEnd - (char*)windowStart) % *size == 0);
+
+   // A run is a sorted subarray. Each recursive call of this function records
+   // the length of one run. At most O(log(n)) lengths of runs are tracked on
+   // the call stack.
+   char* newRun = (char*)windowEnd;
+   while (true) {
+      if (newRun <= (char*)windowStart)
+         return windowEnd;
+
+      newRun -= *size;
+
+      if (newRun <= (char*)*array)
+         return newRun;
+
+      if (mctx->compare(newRun - *size, newRun, mctx->compareContext) > 0) {
+         break;
+      }
+   }
+
+   while (true) {
+      assert(nextWindowSize > 0);
+      assert(nextWindowSize % *size == 0);
+
+      char* nextWindow = windowStart;
+      if (newRun > (char*)windowStart + nextWindowSize) {
+         // This avoids call-preserving "nextWindowSize" (reduces code size).
+         nextWindow += (size_t)(newRun - ((char*)windowStart + nextWindowSize));
+         assert(nextWindow == newRun - nextWindowSize);
+         assert(nextWindow > (char*)windowStart);
+      }
+
+      char* lastRun = newRun;
+      size_t lastRunSize = (size_t)((char*)windowEnd - lastRun);
+      newRun = mergeSortSubarray(mctx, lastRunSize, nextWindow, lastRun);
+      assert(newRun <= lastRun);
+
+      if (newRun >= lastRun) {
+         if (newRun <= (char*)windowStart + nextWindowSize && windowStart > *array)
+            return windowEnd;
+         break;
+      }
+
+      mergeRuns(mctx, newRun, lastRun, windowEnd);
+
+      if (newRun <= (char*)windowStart + lastRunSize) {
+         break;
+      }
+   }
+   return newRun;
+}
+
+static void mergeSort(void* array, size_t len, size_t size, Object_Compare compare, void* context) {
+   if (!size)
+      return;
+
+   assert(len <= SIZE_MAX / size);
+
+   MergeSortContext mctx = {
+      .elementSize = size,
+      .compare = compare,
+      .compareContext = context,
+      .array = array
+   };
+   (void)mergeSortSubarray(&mctx, len * size, array, (char*)array + len * size);
+}
+
+void Generic_sort(void* array, size_t len, size_t size, Object_Compare compare, void* context) {
+   mergeSort(array, len, size, compare, context);
+}