Swift 4 Conform Comparable протокол и проблема метода сортировки

Question

Я пишу следующие структуры, которые соответствуют протоколу Comparable.

struct Record: Comparable {
    static func < (lhs: Record, rhs: Record) -> Bool {
        if lhs.wins == rhs.wins {
            return lhs.losses > rhs.losses
        }
        return lhs.wins < rhs.wins
    }

    var wins: Int
    var losses: Int

    init(wins: Int, losses: Int) {
        self.wins = wins
        self.losses = losses
    }
}

var a1 = Record(wins: 3, losses: 8)
var b1 = Record(wins: 3, losses: 9)
var c1 = Record(wins: 4, losses: 7)

var records = [a1, b1, c1]

records.reverse()
print(records)

Все отлично работает, используя> <== и сортировку тоже.но если я переверну метод сортировки массива записей, он выдаст мне следующий вывод: </p>

[__lldb_expr_48.Record (побед: 4, потерь: 7), __lldb_expr_48.Record (побед: 3, потери: 9), __lldb_expr_48.Record (выигрыши: 3, проигрыши: 8)]

Сначала выигрывают самые высокие выигрыши, за которыми следуют меньшие выигрыши, но если выигрыши равны, тогда меньшие потери должны наступать до больших потерь.Я здесь что-то делаю не так или что-то не так?Я все еще учусь быстро, поэтому возможно.

Answer 1

Чтобы упорядочить массив вещей в обратном порядке сортировки, вы можете просто sort по >:

records.sort(by: >)

reverse просто перевернуть массив, не сортируя его.

Answer 2

Существует также универсальный способ сортировки по вашему желанию без соответствия с Comparable протоколом.Это может быть полезно, если вы применяете различную логику сортировки в разных местах или просто делаете сортировку нечасто.Попробуйте это:

struct SimpleRecord {
    var wins: Int
    var losses: Int
    var name: String
    // we get a simple init for free
}

let a = SimpleRecord(wins: 3, losses: 8, name: "abc")
let b = SimpleRecord(wins: 3, losses: 9, name: "some ")
let c = SimpleRecord(wins: 4, losses: 7, name: "abc")
let d = SimpleRecord(wins: 3, losses: 8, name: "Abc")

var simpleRecords = [a, b, c, d]

simpleRecords.sort(by: { (lhs, rhs) -> Bool in
    if lhs.wins > rhs.wins {
        return true
    } else if lhs.wins == rhs.wins {
        if lhs.losses < rhs.losses {
            return true
        } else if lhs.losses == rhs.losses {
            return (lhs.name.localizedStandardCompare(rhs.name) == ComparisonResult.orderedDescending)
        } else {
            return false
        }
    } else {
        return false
    }
})

// print(simpleRecords) // it is a lazy collection so print is a bit messy
simpleRecords.forEach{ print($0) }

Обратите внимание, как мы можем использовать нетривиальные (но эффективные) предопределенные алгоритмы сортировки для строк (из Foundation), такие как «localizedStandardCompare», «localizedCompare» и т. Д.

Answer 3

Вы просто не сортируете свой массив перед тем, как инвертировать его

records.sort()
records.reverse()