Merge pull request #1767 from pguyot/w29/replace-quicksort-with-mergesort

Replace quick_sort with merge_sort for lists

These changes are made under both the "Apache 2.0" and the "GNU Lesser General
Public License 2.1 or later" license terms (dual license).

SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later

Author: bettio

CHANGELOG.md

@@ -9,11 +9,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Added `lists:keysort/2`
+- Added `lists:merge/2,3`
 
 ### Fixed
 
 - Fixed a bug where binary matching could fail due to a missing preservation of the matched binary.
 
+### Changed
+
+- lists sort function now use a stable merge sort implementation instead of quick sort
+
 ## [0.6.6] - 2025-06-23
 
 ### Added

libs/estdlib/src/lists.erl

@@ -58,6 +58,7 @@
     join/2,
     seq/2, seq/3,
     sort/1, sort/2,
+    merge/2, merge/3,
     split/2,
     usort/1, usort/2,
     duplicate/2,
@@ -650,8 +651,23 @@ sort(List) when is_list(List) ->
 %% @end
 %%-----------------------------------------------------------------------------
 -spec sort(Fun :: fun((T, T) -> boolean()), List :: [T]) -> [T].
-sort(Fun, List) when is_function(Fun), is_list(List) ->
-    quick_sort(Fun, List).
+sort(Fun, List) when is_function(Fun, 2), is_list(List) ->
+    merge_sort(Fun, List).
+
+merge_sort(_Fun, []) ->
+    [];
+merge_sort(_Fun, [_] = L) ->
+    L;
+merge_sort(Fun, List) ->
+    {H1, H2} = merge_sort_split(List, List, []),
+    merge(Fun, merge_sort(Fun, H1), merge_sort(Fun, H2), []).
+
+merge_sort_split([], Half1, Half2) ->
+    {lists:reverse(Half2), Half1};
+merge_sort_split([_], Half1, Half2) ->
+    {lists:reverse(Half2), Half1};
+merge_sort_split([_, _ | T], [H | Half1T], Half2) ->
+    merge_sort_split(T, Half1T, [H | Half2]).
 
 %%-----------------------------------------------------------------------------
 %% @param   N elements non negative Integer
@@ -686,14 +702,39 @@ split(N, [H | T], R) ->
 split(_, [], _) ->
     badarg.
 
-%% Attribution: https://erlang.org/doc/programming_examples/list_comprehensions.html#quick-sort
-%% @private
-quick_sort(Fun, [Pivot | T]) ->
-    quick_sort(Fun, [X || X <- T, Fun(X, Pivot)]) ++
-        [Pivot] ++
-        quick_sort(Fun, [X || X <- T, not Fun(X, Pivot)]);
-quick_sort(_Fun, []) ->
-    [].
+%%-----------------------------------------------------------------------------
+%% @param   List1 first list to merge, previously sorted
+%% @param   List2 second list to merge, previously sorted
+%% @returns Merged list of List1 and List2
+%% @doc     Returns a list formed by merging List1 and List2, following natural
+%%          order. If elements compare equal, element from List1 is picked first
+%% @end
+%%-----------------------------------------------------------------------------
+merge(List1, List2) ->
+    merge(fun lt/2, List1, List2, []).
+
+%%-----------------------------------------------------------------------------
+%% @param   Fun ordering function
+%% @param   List1 first list to merge, previously sorted
+%% @param   List2 second list to merge, previously sorted
+%% @returns Merged list of List1 and List2
+%% @doc     Returns a list formed by merging List1 and List2, following Fun
+%%          order. If elements compare equal, element from List1 is picked first
+%% @end
+%%-----------------------------------------------------------------------------
+merge(Fun, List1, List2) ->
+    merge(Fun, List1, List2, []).
+
+merge(_Fun, [], Right, Acc) ->
+    lists:reverse(Acc, Right);
+merge(_Fun, Left, [], Acc) ->
+    lists:reverse(Acc, Left);
+merge(Fun, [A | As], [B | Bs], Acc) ->
+    % keep sort stable, if B < A, put it first, otherwise keep A first
+    case Fun(B, A) of
+        true -> merge(Fun, [A | As], Bs, [B | Acc]);
+        false -> merge(Fun, As, [B | Bs], [A | Acc])
+    end.
 
 %% @private
 lt(A, B) -> A < B.

tests/libs/estdlib/test_lists.erl

@@ -131,6 +131,34 @@ test_keysort() ->
     ?ASSERT_MATCH(lists:keysort(2, [{foo, 2}, {bar, 1}]), [{bar, 1}, {foo, 2}]),
     ?ASSERT_ERROR(lists:keysort(1, [1, 2])),
     ?ASSERT_ERROR(lists:keysort(3, [{1, bar}, {2, foo}])),
+
+    % Our sort is always stable, but older versions of OTP only have
+    % keysort/2 documented as stable
+    ?ASSERT_MATCH(
+        lists:keysort(1, [
+            {3, a}, {2, c}, {1, z}, {2, b}, {2, a}
+        ]),
+        [{1, z}, {2, c}, {2, b}, {2, a}, {3, a}]
+    ),
+    ?ASSERT_MATCH(
+        lists:keysort(1, [
+            {3, a}, {1, z}, {2, c}, {2, b}, {2, a}
+        ]),
+        [{1, z}, {2, c}, {2, b}, {2, a}, {3, a}]
+    ),
+    ?ASSERT_MATCH(
+        lists:keysort(1, [
+            {3, a}, {2, c}, {2, b}, {1, z}, {2, a}
+        ]),
+        [{1, z}, {2, c}, {2, b}, {2, a}, {3, a}]
+    ),
+    ?ASSERT_MATCH(
+        lists:keysort(1, [
+            {3, a}, {2, c}, {2, b}, {2, a}, {1, z}
+        ]),
+        [{1, z}, {2, c}, {2, b}, {2, a}, {3, a}]
+    ),
+
     ok.
 
 test_keystore() ->