Check if sorting implementation is stable

Introduced node numbering in qtest.c to evaluate q_sort's stability.

When encountering two nodes with the same value, the algorithm searches
for the address of the node record in the nodes array. It then compares
the found node to the current node (cur). If the found node is the same
as the current node, it indicates that these two duplicate nodes have
not been swapped in position after sorting. However, if the found node
is cur->next, it means that the position of the nodes has been swapped.

This method avoids altering the structure and instead relies on
auxiliary data structures to track node pointersand their original
order. However, stability testing is limited to a maximum number of
elements, currently set as MAX_NODES, to mitigate potential performance
issues. Note: If the dataset is too large, it may lead to excessively
long test times, hence the use of MAX_NODES.

Testing with the following script to measure the elapsed time for
inserting different numbers of nodes:

new
ih a 10000
sort
quit

| node count | elapsed time (seconds) |
| ---------- | ---------------------- |
| 1000       | 0.027906238            |
| 10000      | 0.058188249            |
| 100000     | 2.445569385            |
| 150000     | 5.453358783            |
| 200000     | 9.671944194            |
| 300000     | 21.581793918           |
| 400000     | 40.176436261           |
| 500000     | 61.437037665           |

The test results reveal a noticeable increase in elapsed time as the
number of nodes inserted grows. Specifically, exceeding 100,000 nodes
results in significant performance degradation.

Author: yenslife

qtest.c

@@ -600,6 +600,23 @@ bool do_sort(int argc, char *argv[])
     error_check();
 
     set_noallocate_mode(true);
+
+/* If the number of elements is too large, it may take a long time to check the
+ * stability of the sort. So, MAX_NODES is used to limit the number of elements
+ * to check the stability of the sort. */
+#define MAX_NODES 100000
+    struct list_head *nodes[MAX_NODES];
+    unsigned no = 0;
+    if (current && current->size && current->size <= MAX_NODES) {
+        element_t *entry;
+        list_for_each_entry (entry, current->q, list)
+            nodes[no++] = &entry->list;
+    } else if (current && current->size > MAX_NODES)
+        report(1,
+               "Warning: Skip checking the stability of the sort because the "
+               "number of elements %d is too large, exceeds the limit %d.",
+               current->size, MAX_NODES);
+
     if (current && exception_setup(true))
         q_sort(current->q, descend);
     exception_cancel();
@@ -624,8 +641,32 @@ bool do_sort(int argc, char *argv[])
                 ok = false;
                 break;
             }
+            /* Ensure the stability of the sort */
+            if (current->size <= MAX_NODES &&
+                !strcmp(item->value, next_item->value)) {
+                bool unstable = false;
+                for (unsigned i = 0; i < MAX_NODES; i++) {
+                    if (nodes[i] == cur_l->next) {
+                        unstable = true;
+                        break;
+                    }
+                    if (nodes[i] == cur_l) {
+                        break;
+                    }
+                }
+                if (unstable) {
+                    report(
+                        1,
+                        "ERROR: Not stable sort. The duplicate strings \"%s\" "
+                        "are not in the same order.",
+                        item->value);
+                    ok = false;
+                    break;
+                }
+            }
         }
     }
+#undef MAX_NODES
 
     q_show(3);
     return ok && !error_check();
@@ -1263,4 +1304,4 @@ int main(int argc, char *argv[])
     ok = finish_cmd() && ok;
 
     return !ok;
-}
+}