fix: build OrderedSet/OrderedCollection/OrderedMap in O(n log n) and stop OrderedSet set operations going quadratic [patch]

[matt-edmondson]

Fixes #82

Summary

The sorted containers' bulk constructors filled the backing List<T> one binary-search Insert at a time, so building from n unsorted or reverse-sorted items was O(n²). OrderedSet.ToComparerSet goes through that constructor, which made IsSubsetOf, IsProperSubsetOf, IsProperSupersetOf, SetEquals, IntersectWith and SymmetricExceptWith quadratic in the size of the argument.

• New StableSort (internal): a top-down merge sort with an insertion-sort cutoff. It takes from the left half on ties, so it is stable, and it skips the merge when two halves are already in order, so sorted input (such as Clone) costs O(n).
• OrderedSet(IEnumerable<T>[, comparer]): copies, stable-sorts, then drops adjacent equal elements and keeps the first, which is what repeated Add calls did.
• OrderedCollection(IEnumerable<T>[, comparer]): copies and stable-sorts, so equal elements keep their input order, as Add (upper-bound insert) does.
• OrderedMap(IDictionary[, comparer]): copies entries, checks for null keys, stable-sorts by key, and throws the same ArgumentException (same message) that Add throws when two keys compare equal under the comparer.
• OrderedSet set operations:
  • ToComparerSet now reuses an OrderedSet<T> argument that has the same comparer instead of copying it.
  • IntersectWith compacts in one pass with RemoveAll instead of calling RemoveAt once per removed element.
  • SymmetricExceptWith now does a single linear merge of the two sorted lists. The old code made repeated RemoveAt, Remove and Add calls, each of which is O(n). A call on the set itself still empties it, and an OrderedSet argument is no longer modified.
  • IsSupersetOf and Overlaps are unchanged.

#80 is not addressed beyond what this naturally covers.

Testing

New tests:

• Performance, using a Stopwatch with a 5 s budget on 1,000,000 elements:
  • construction from descending input for OrderedSet, OrderedCollection and OrderedMap
  • OrderedSet.IsSubsetOf, SetEquals, IntersectWith and SymmetricExceptWith against a descending array
• Semantics:
  • OrderedSet keeps the first occurrence of duplicates, using 1,000 items with a key comparer so the merge path runs.
  • OrderedSet honours a case-insensitive comparer and a reverse comparer.
  • Bulk construction matches repeated Add on random input.
  • OrderedMap throws ArgumentException on keys that compare equal, matching Add, and honours a custom comparer.
  • OrderedCollection keeps equal elements in insertion order, using 1,000 items so the merge path runs.
  • SymmetricExceptWith works on the set itself and on an OrderedSet with the same comparer.

Revert proof: I stashed only the three production files (OrderedSet.cs, OrderedCollection.cs, OrderedMap.cs) and ran the new tests. All 7 performance tests failed their budget. The OrderedSet/OrderedCollection cases took about 73–98 s and the OrderedMap constructor took about 174 s, against a 5 s budget. The semantics tests passed on both paths, as expected, because they check behaviour that already existed. With the fix restored, all of them pass, and the whole suite runs in about 4 s.

Full suite: dotnet test reports 470/470 passed. dotnet build -c Release reports 0 warnings and 0 errors.

🤖 Generated with Claude Code

https://claude.ai/code/session_01K6bDUGMFsAQews3TnA2jXr

---

Generated by Claude Code

[sonarqubecloud]

Quality Gate passed

Issues
1 New issue
0 Accepted issues

Measures
0 Security Hotspots
97.6% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud