expanded class COMPARATOR_COLLECTION_SORTER [X]

Features exported to ANY

Some algorithms to sort any COLLECTION using an external comparator.

Elements are sorted using the order given by the comparator: large elements at the beginning of the collection, small at the end (increasing order is implemented by class COLLECTION_SORTER).

Note that without setting a comparator (using set_comparator), collections won't get sorted.

How to use this expanded class :

         local
            sorter: COMPARATOR_COLLECTION_SORTER[INTEGER]
            array: ARRAY[INTEGER]
         do
            array := <<1,3,2>>
            sorter.set_comparator(agent my_comparator)
            sorter.sort(array)
            check
               sorter.is_sorted(array)
            end
            ...

Direct parents

conformant parents

ABSTRACT_SORTER

Summary

creation features

exported features

Details

default_create

Default creation method. It is used when no creation method is specified if allowed. Note it may be renamed.

with_comparator (a_comparator: PREDICATE[TUPLE[TUPLE 2[XX]]])
set_comparator (a_comparator: PREDICATE[TUPLE[TUPLE 2[XX]]])
comparator: PREDICATE[TUPLE[TUPLE 2[XX]]]
is_sorted (c: COLLECTION[X]): BOOLEAN

Is c already sorted ? Uses lte for comparison.

require

  • c /= Void

ensure

  • c.is_equal(old c.twin)

has (c: COLLECTION[X], element: X): BOOLEAN

require

  • c /= Void
  • is_sorted(c)

ensure

  • Result = c.has(element)

index_of (c: COLLECTION[X], element: X): INTEGER

require

  • c /= Void
  • is_sorted(c)

ensure

  • not c.is_empty implies c.valid_index(Result)
  • c.has(element) implies c.item(Result).is_equal(element)

add (c: COLLECTION[X], element: X)

Add element in collection c keeping the sorted property.

require

  • c /= Void
  • is_sorted(c)

ensure

  • c.count = old c.count + 1
  • is_sorted(c)

insert_index (c: COLLECTION[X], element: X): INTEGER

retrieve the upper index for wich gt

require

  • c /= Void
  • is_sorted(c)

ensure

  • Result.in_range(c.lower, c.upper + 1)

sort (c: COLLECTION[X])

Sort c using the default most efficient sorting algorithm already implemented.

require

  • c /= Void

ensure

  • c.count = old c.count
  • is_sorted(c)

quick_sort (c: COLLECTION[X])

Sort c using the quick sort algorithm.

require

  • c /= Void

ensure

  • c.count = old c.count
  • is_sorted(c)

von_neuman_sort (c: COLLECTION[X])

Sort c using the Von Neuman algorithm. This algorithm needs to create a second collection. Uses infix "lte" for comparison.

require

  • c /= Void

ensure

  • c.count = old c.count
  • is_sorted(c)

heap_sort (c: COLLECTION[X])

Sort c using the heap sort algorithm.

require

  • c /= Void

ensure

  • c.count = old c.count
  • is_sorted(c)

bubble_sort (c: COLLECTION[X])

Sort c using the bubble sort algorithm. Uses infix "<" for comparison.

require

  • c /= Void

ensure

  • c.count = old c.count
  • is_sorted(c)