Changed sorting for external lists.

Author: uhop

src/list/ext.d.ts

@@ -164,7 +164,7 @@ export class ExtList<T extends object = object> extends ExtListBase<T> {
   reverse(): this;
 
   /**
-   * Sort nodes in place using merge sort.
+   * Sort nodes in place using a stable natural merge sort (O(n) on already-sorted input).
    * @param lessFn - Comparison function returning `true` if `a` should precede `b`.
    * @returns `this` for chaining.
    */

src/list/ext.js

@@ -2,6 +2,7 @@
 
 import {ExtListBase, PtrBase} from './nodes.js';
 import {pop, extract, splice, append} from './basics.js';
+import List from './core.js';
 import {addAliases, mapIterator, normalizeIterator} from '../meta-utils.js';
 
 export class Ptr extends PtrBase {
@@ -221,46 +222,12 @@ export class ExtList extends ExtListBase {
   sort(lessFn) {
     if (this.isOneOrEmpty) return this;
 
-    const left = this.make(),
-      right = this.make();
+    // delegate to the hosted stable natural merge sort; head lands on the sorted first node
+    const list = List.fromExtList(this);
+    list.sort(lessFn);
+    this.attach(list.releaseRawList());
 
-    // split into two sublists
-    let isLeft = true;
-    for (const current of this.getNodeIterator()) {
-      current[this.nextName] = current[this.prevName] = current; // make stand-alone
-      if (isLeft) {
-        left.addNodeAfter(current);
-        left.next();
-      } else {
-        right.addNodeAfter(current);
-        right.next();
-      }
-      isLeft = !isLeft;
-    }
-    this.clear();
-    // the list is empty now
-
-    // sort sublists
-    left.next().sort(lessFn);
-    right.next().sort(lessFn);
-
-    // merge sublists
-    while (!left.isEmpty && !right.isEmpty) {
-      this.addNodeAfter((lessFn(left.head, right.head) ? left : right).removeCurrent());
-      this.next();
-    }
-    if (!left.isEmpty) {
-      const last = left.head[left.prevName];
-      this.insertAfter(left);
-      this.head = last;
-    }
-    if (!right.isEmpty) {
-      const last = right.head[right.prevName];
-      this.insertAfter(right);
-      this.head = last;
-    }
-
-    return this.next();
+    return this;
   }
 
   [Symbol.iterator]() {

src/slist/core.d.ts

@@ -263,7 +263,10 @@ export class SList<T extends object = object> extends HeadNode {
   static fromRange<T extends object = object>(range: SllRange<T> | null, options?: SllOptions): SList<T>;
 
   /**
-   * Build an SList from an external list, consuming it.
+   * Build an SList from an external list, consuming it. By contract the result is
+   * **rotated by one**: it starts at `extList.head`'s next node and the old head lands
+   * last — the O(1) conversion (an order-faithful copy would cost an O(n) walk to find
+   * the ring's back; do it via `getBack()` when order matters).
    * @param extList - External list to consume.
    * @returns A new SList.
    */

src/slist/ext.d.ts

@@ -121,7 +121,7 @@ export class ExtSList<T extends object = object> extends ExtListBase<T> {
   reverse(): this;
 
   /**
-   * Sort nodes in place using merge sort.
+   * Sort nodes in place using a stable natural merge sort (O(n) on already-sorted input).
    * @param lessFn - Returns `true` if `a` should precede `b`.
    * @returns `this` for chaining.
    */

src/slist/ext.js

@@ -1,7 +1,8 @@
 // @ts-self-types="./ext.d.ts"
 
 import {ExtListBase, PtrBase} from './nodes.js';
-import {pop, extract, splice} from './basics.js';
+import {pop, extract, splice, append} from './basics.js';
+import SList from './core.js';
 import {addAliases, normalizeIterator} from '../meta-utils.js';
 
 export class Ptr extends PtrBase {
@@ -171,66 +172,18 @@ export class ExtSList extends ExtListBase {
   sort(lessFn) {
     if (this.isOneOrEmpty) return this;
 
-    const leftHead = {},
-      rightHead = {};
-    leftHead[this.nextName] = leftHead;
-    rightHead[this.nextName] = rightHead;
-
-    const left = this.make(leftHead),
-      right = this.make(rightHead);
-
-    // split into two sublists
-    let isLeft = true;
-    for (const current of this.getNodeIterator()) {
-      current[this.nextName] = current; // make stand-alone
-      if (isLeft) {
-        left.addNodeAfter(current);
-        left.next();
-      } else {
-        right.addNodeAfter(current);
-        right.next();
-      }
-      isLeft = !isLeft;
-    }
-    left.removeNodeAfter(); // remove the head node
-    right.removeNodeAfter(); // remove the head node
+    // delegate to the hosted stable natural merge sort; head lands on the sorted first node
+    // (SList.fromExtList is unsuitable: the SLL ext range starts at head.next — a rotation
+    // that would break stability relative to the original order)
+    const list = new SList(this),
+      back = this.getBack();
+    append(list, list, {prevFrom: back, to: back});
+    list.last = back;
     this.clear();
-    // the list is empty now
-
-    // sort sublists
-    left.next().sort(lessFn);
-    right.next().sort(lessFn);
-
-    // merge sublists
-    const leftIterator = left.getNodeIterator()[Symbol.iterator](),
-      rightIterator = right.getNodeIterator()[Symbol.iterator]();
-    let leftItem = leftIterator.next(),
-      rightItem = rightIterator.next();
-    while (!leftItem.done && !rightItem.done) {
-      let node;
-      if (lessFn(leftItem.value, rightItem.value)) {
-        node = leftItem.value;
-        leftItem = leftIterator.next();
-      } else {
-        node = rightItem.value;
-        rightItem = rightIterator.next();
-      }
-      node[this.nextName] = node; // make stand-alone
-      this.addNodeAfter(node);
-      this.next();
-    }
-    for (; !leftItem.done; this.next(), leftItem = leftIterator.next()) {
-      const node = leftItem.value;
-      node[this.nextName] = node; // make stand-alone
-      this.addNodeAfter(node);
-    }
-    for (; !rightItem.done; this.next(), rightItem = rightIterator.next()) {
-      const node = rightItem.value;
-      node[this.nextName] = node; // make stand-alone
-      this.addNodeAfter(node);
-    }
+    list.sort(lessFn);
+    this.attach(list.releaseRawList());
 
-    return this.next();
+    return this;
   }
 
   [Symbol.iterator]() {

tests/test-sorted-ops.js

@@ -3,6 +3,8 @@ import List from 'list-toolkit/list.js';
 import SList from 'list-toolkit/slist.js';
 import ValueList from 'list-toolkit/value-list.js';
 import ValueSList from 'list-toolkit/value-slist.js';
+import ExtList from 'list-toolkit/ext-list.js';
+import ExtSList from 'list-toolkit/ext-slist.js';
 
 const makeLcg =
   (seed = 42) =>
@@ -123,6 +125,46 @@ test('sort - correctness across shapes', t => {
   }
 });
 
+test('sort - ext lists parity and stability', t => {
+  const random = makeLcg(11);
+  {
+    const items = Array.from({length: 100}, (_, i) => ({k: Math.floor(random() * 10), i})),
+      ext = new ExtList(List.from(items).releaseRawList());
+    ext.sort(lessNode);
+    const result = Array.from(ext.getNodeIterator());
+    t.equal(result.length, 100, 'ExtList: all nodes present');
+    t.equal(ext.head, result[0], 'ExtList: head is the sorted first node');
+    let stable = true;
+    for (let i = 1; i < result.length; ++i) {
+      const prev = result[i - 1],
+        curr = result[i];
+      if (prev.k > curr.k || (prev.k === curr.k && prev.i > curr.i)) {
+        stable = false;
+        break;
+      }
+    }
+    t.ok(stable, 'ExtList: sorted and stable');
+  }
+  {
+    const items = Array.from({length: 100}, (_, i) => ({k: Math.floor(random() * 10), i})),
+      ext = new ExtSList(SList.from(items).releaseRawList());
+    ext.sort(lessNode);
+    const result = Array.from(ext.getNodeIterator());
+    t.equal(result.length, 100, 'ExtSList: all nodes present');
+    t.equal(ext.head, result[0], 'ExtSList: head is the sorted first node');
+    let stable = true;
+    for (let i = 1; i < result.length; ++i) {
+      const prev = result[i - 1],
+        curr = result[i];
+      if (prev.k > curr.k || (prev.k === curr.k && prev.i > curr.i)) {
+        stable = false;
+        break;
+      }
+    }
+    t.ok(stable, 'ExtSList: sorted and stable');
+  }
+});
+
 test('sort - stability', t => {
   const random = makeLcg(7);
   for (const Ctor of [List, SList]) {