Sorts the collection in place, using the given predicate as the comparison between elements.
SDK
- Xcode 8.0+
Framework
- Swift Standard Library
Declaration
mutating func sort(by areInIncreasingOrder: (Element, Element) throws -> Bool) rethrows
Parameters
areInIncreasingOrder
A predicate that returns
true
if its first argument should be ordered before its second argument; otherwise,false
. Ifare
throws an error during the sort, the elements may be in a different order, but none will be lost.In Increasing Order
Discussion
When you want to sort a collection of elements that don’t conform to the Comparable
protocol, pass a closure to this method that returns true
when the first element should be ordered before the second.
In the following example, the closure provides an ordering for an array of a custom enumeration that describes an HTTP response. The predicate orders errors before successes and sorts the error responses by their error code.
enum HTTPResponse {
case ok
case error(Int)
}
var responses: [HTTPResponse] = [.error(500), .ok, .ok, .error(404), .error(403)]
responses.sort {
switch ($0, $1) {
// Order errors by code
case let (.error(aCode), .error(bCode)):
return aCode < bCode
// All successes are equivalent, so none is before any other
case (.ok, .ok): return false
// Order errors before successes
case (.error, .ok): return true
case (.ok, .error): return false
}
}
print(responses)
// Prints "[.error(403), .error(404), .error(500), .ok, .ok]"
Alternatively, use this method to sort a collection of elements that do conform to Comparable
when you want the sort to be descending instead of ascending. Pass the greater-than operator (>
) operator as the predicate.
var students = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]
students.sort(by: >)
print(students)
// Prints "["Peter", "Kweku", "Kofi", "Akosua", "Abena"]"
are
must be a strict weak ordering over the elements. That is, for any elements a
, b
, and c
, the following conditions must hold:
are
is alwaysIn Increasing Order(a, a) false
. (Irreflexivity)If
are
andIn Increasing Order(a, b) are
are bothIn Increasing Order(b, c) true
, thenare
is alsoIn Increasing Order(a, c) true
. (Transitive comparability)Two elements are incomparable if neither is ordered before the other according to the predicate. If
a
andb
are incomparable, andb
andc
are incomparable, thena
andc
are also incomparable. (Transitive incomparability)
The sorting algorithm is not guaranteed to be stable. A stable sort preserves the relative order of elements for which are
does not establish an order.
Complexity: O(n log n), where n is the length of the collection.