expanded class REVERSE_COLLECTION_SORTER [X -> COMPARABLE]

Features exported to ANY

Some algorithms to sort any COLLECTION[COMPARABLE].

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).

How to use this expanded class :

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

Direct parents

conformant parents

ABSTRACT_SORTER

Summary

exported features

Details

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)