Logo

Programming-Idioms

  • Kotlin
  • C++
  • Java
  • Obj-c

Idiom #100 Sort by a comparator

Sort elements of array-like collection items, using a comparator c.

@import Foundation;
[items sortUsingComparator:c];

Sorts in-place; for creation of a new sorted array leaving the receiver unchanged there's sortedArrayUsingComparator:
items.sortWith(c)
#include <algorithm>
std::ranges::sort(items, c);

Requires C++20.
#include <algorithm>
#include <vector>
#include <cassert>
struct is_less {
    bool operator () (int a, int b){
        return a < b;
    }
};

int main(){
    std::vector<int> items = {1337, 666, -666, 0, 0, 666, -666};
    std::sort(items.begin(), items.end(), is_less());

    std::vector<int> expected = {-666, -666, 0, 0, 666, 666, 1337};
    assert(items.size() == expected.size());
    for (size_t i = 0; i < items.size(); i++){
        assert(items[i] == expected[i]);
    }
    return 0;
}

c is a bad name for a comparator because it is not descriptive. is_less is a better name.

The initializer list for items requires the compiler parameter -std=c++11

std::sort might not be stable. If you want a stable sorting algorithm, use std::stable_sort instead.

import java.util.Arrays;
import java.util.Comparator;
Arrays.sort(items, c);

items is an array of type Item[].
c implements Comparator<Item>.
import java.util.Collections;
import java.util.Comparator;
Collections.sort(items, c);

items is a List<Item>.
c implements Comparator<Item>.
with Ada.Containers.Vectors;
use Ada.Containers;
type Integer_Comparator is not null access function (Left, Right : Integer) return Boolean;
      
package Integer_Vectors is new Vectors (Positive, Integer);
use Integer_Vectors;
      
procedure Sort_Using_Comparator (V : in out Vector; C : Integer_Comparator) is
   package Vector_Sorting is new Generic_Sorting (C.all);
   use Vector_Sorting;
         
begin
   Sort (V);
end Sort_Using_Comparator;
New implementation...
< > ⌨
programming-idioms.org 
[items sortUsingComparator:c];
items.sortWith(c)
std::ranges::sort(items, c);
struct is_less {
    bool operator () (int a, int b){
        return a < b;
    }
};

int main(){
    std::vector<int> items = {1337, 666, -666, 0, 0, 666, -666};
    std::sort(items.begin(), items.end(), is_less());

    std::vector<int> expected = {-666, -666, 0, 0, 666, 666, 1337};
    assert(items.size() == expected.size());
    for (size_t i = 0; i < items.size(); i++){
        assert(items[i] == expected[i]);
    }
    return 0;
}

Arrays.sort(items, c);
Collections.sort(items, c);
type Integer_Comparator is not null access function (Left, Right : Integer) return Boolean;
      
package Integer_Vectors is new Vectors (Positive, Integer);
use Integer_Vectors;
      
procedure Sort_Using_Comparator (V : in out Vector; C : Integer_Comparator) is
   package Vector_Sorting is new Generic_Sorting (C.all);
   use Vector_Sorting;
         
begin
   Sort (V);
end Sort_Using_Comparator;
int c(const void *a,const void *b)
{
	int x = *(const int *)a;
	int y = *(const int *)b;

	if (x < y) return -1;
	if (x > y) return +1;
	return 0;
}

int main(void)
{
	int arr[]={1,6,3,7,2};
	qsort(arr,sizeof(arr)/sizeof(*arr),sizeof(*arr),c);

	return 0;
}

(sort c items)
items.Sort(c);
Array.Sort(items, c);
var orderdEnumerable = x.OrderBy(y => y, c);
items.sort!c;
items.sort(c);
Enum.sort(items, c)
lists:sort(C, List).
sort.Slice(items, func(i, j int) bool {
	return c(items[i], items[j])
})
type ItemsSorter struct {
	items []Item
	c     func(x, y Item) bool
}

func (s ItemsSorter) Len() int           { return len(s.items) }
func (s ItemsSorter) Less(i, j int) bool { return s.c(s.items[i], s.items[j]) }
func (s ItemsSorter) Swap(i, j int)      { s.items[i], s.items[j] = s.items[j], s.items[i] }

func sortItems(items []Item, c func(x, y Item) bool) {
	sorter := ItemsSorter{
		items,
		c,
	}
	sort.Sort(sorter)
}
slices.SortFunc(items, c)
type ItemCSorter []Item
func (s ItemCSorter) Len() int           { return len(s) }
func (s ItemCSorter) Less(i, j int) bool { return c(s[i], s[j]) }
func (s ItemCSorter) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func sortItems(items []Item) {
	sorter := ItemCSorter(items)
	sort.Sort(sorter)
}
result = sortBy c items
items.sort(c);
(sort items #'c)

table.sort(items,c)
uasort($items, $c);
with TList.Create do try
  Sort(c);
finally
  Free;
end;
sub c {
 $a <=> $b;
}

my @result = sort c @items;


items.sort(key=c)
items.sort(key=functools.cmp_to_key(c))
items.sort!(&c)
items.sort!{|a,b| a-b }
items.sort_by(c);
val c: Ordering[Int] = Ordering.Int
val sortedItems = items.sorted(c)

// Or using implicits:

val sortedItems = items.sorted
| c |
c := [ :a :b | a size <= b size ].  " example c for strings "
#('a' 'aaa' 'a' 'aaaa') asSortedCollection: c.
" => SortedCollection('a' 'a' 'aaa' 'aaaa') "