假设我有一个自定义类 [Player] 的数组，每个类都包含一个名为 player.position 的字符串属性

我还有一个任意值数组，称为 positionOrders，如下所示:

让 positionOrders = ["QB", "WR", "RB", "TE"]

我的目标是对 [Player] 进行排序，使所有“QB”排在第一位，然后是“WR”、“RB”，最后是“TE”。

我目前的做法是循环遍历 positionOrders 中的每个元素，然后在其中循环遍历所有玩家以附加到新数组。但是，我想不出更简单(也更有效)的方法来做到这一点。非常感谢任何提示或指示。谢谢。

最佳答案

编辑:我原来的方法很糟糕。这篇文章引起了很大的关注，所以是时候给予它更多的关注和改进了。

从根本上说，这个问题很简单。我们有两个元素，我们有一个数组(或任何有序的 Collection)，其相对顺序决定了它们的排序顺序。对于每个元素，我们找到它在有序集合中的位置，并比较两个索引以确定哪个“更大”。

但是，如果我们天真地进行线性搜索(例如 Array.firstIndex(of:))，我们将获得非常糟糕的性能(O(array.count) )，特别是如果固定顺序非常大。为了解决这个问题，我们可以构造一个 Dictionary，将元素映射到它们的索引。该字典提供快速的 O(1) 查找，非常适合这项工作。

这正是 HardCodedOrdering 所做的。它根据元素的顺序预先计算元素字典，并提供一个接口(interface)来比较 2 个元素。更好的是，它可以配置为以不同方式响应遇到具有未知顺序的元素。它可以将它们放在首位，放在其他所有内容之后，最后放在其他所有内容之后，或者完全崩溃(默认行为)。

硬编码排序

public struct HardCodedOrdering<Element> where Element: Hashable {
    public enum UnspecifiedItemSortingPolicy {
        case first
        case last
        case assertAllItemsHaveDefinedSorting
    }

    private let ordering: [Element: Int]
    private let sortingPolicy: UnspecifiedItemSortingPolicy

    public init(
        ordering: Element...,
        sortUnspecifiedItems sortingPolicy: UnspecifiedItemSortingPolicy = .assertAllItemsHaveDefinedSorting
    ) {
        self.init(ordering: ordering, sortUnspecifiedItems: sortingPolicy)
    }

    public init<S: Sequence>(
        ordering: S,
        sortUnspecifiedItems sortingPolicy: UnspecifiedItemSortingPolicy = .assertAllItemsHaveDefinedSorting
    ) where S.Element == Element {

        self.ordering = Dictionary(uniqueKeysWithValues: zip(ordering, 1...))
        self.sortingPolicy = sortingPolicy
    }

    private func sortKey(for element: Element) -> Int {
        if let definedSortKey = self.ordering[element] { return definedSortKey }

        switch sortingPolicy {
            case .first:    return Int.min
            case .last:     return Int.max

            case .assertAllItemsHaveDefinedSorting:
                fatalError("Found an element that does not have a defined ordering: \(element)")
        }
    }

    public func contains(_ element: Element) -> Bool {
        return self.ordering.keys.contains(element)
    }

    // For use in sorting a collection of `T`s by the value's yielded by `keyDeriver`.
    // A throwing varient could be introduced, if necessary.
    public func areInIncreasingOrder<T>(by keyDeriver: @escaping (T) -> Element) -> (T, T) -> Bool {
        return { lhs, rhs in
            self.sortKey(for: keyDeriver(lhs)) < self.sortKey(for: keyDeriver(rhs))
        }   
    }

    // For use in sorting a collection of `Element`s
    public func areInIncreasingOrder(_ lhs: Element, rhs: Element) -> Bool {        
        return sortKey(for: lhs) < sortKey(for: rhs)
    }
}

示例用法:

let rankOrdering = HardCodedOrdering(ordering: "Private", "Lieutenant", "Captain", "Admiral") // ideally, construct this once, cache it and share it

let someRanks = [
    "Admiral", // Should be last (greatest)
    "Gallactic Overlord", // fake, should be removed
    "Private", // Should be first (least)
]
let realRanks = someRanks.lazy.filter(rankOrdering.contains)
let sortedRealRanks = realRanks.sorted(by: rankOrdering.areInIncreasingOrder) // works with mutating varient, `sort(by:)`, too.

print(sortedRealRanks) // => ["Private", "Admiral"]

关于arrays - 通过从另一个数组排序来对 Swift 数组进行排序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43056807/