我如何定义哪个函数更有效地将数组与自定义模型进行比较

Question

我写了两个函数来比较数组。现在我正在努力如何比较这些方法并找出最合适的方法。

我想知道如何评估我编写的每个函数。

我知道数组的所有元素都是相同的。

通过评估，我询问的是性能（时间和复杂性）以及 Swift 功能的使用情况。

我在数组中使用的结构：

struct Wallet {
    var fund = 0
    var name = ""

    public static func ==(lhs: Wallet, rhs: Wallet) -> Bool{
        return lhs.fund == rhs.fund && lhs.name == rhs.name
    }

    public static func !=(lhs: Wallet, rhs: Wallet) -> Bool{
        return lhs.fund != rhs.fund || lhs.name != rhs.name
    }
} 

使用zip的第一种方法：

func compare(x: Array<Wallet>, y: Array<Wallet>) -> Bool {
    let state = zip(x, y).enumerated().filter() {
        $1.0 == $1.1
        }.count == x.count
    return state
}

对数组进行排序并进行比较时的第二种方法。

func compare(x: Array<Wallet>, y: Array<Wallet>) -> Bool {

    if x.count != y.count {
        return false
    }

    let xSorted = x.sorted{$0.fund > $1.fund}
    let ySorted = y.sorted{$0.fund > $1.fund}

    for (pos, xItem) in xSorted.enumerated() {
        let yItem = ySorted[pos]
        if xItem != yItem {
            return false
        }
    }

    return true
}

Answer 1

两种解决方案都不是最优的：

• 调用enumerated() 是不必要的，因为索引位置是 没有在闭包中使用。
• 两种解决方案都不会短路：它们比较所有数组元素 即使找到不同的对。

contains() 会短路，所以这将是一个更好的解决方案：

func compare(x: Array<Wallet>, y: Array<Wallet>) -> Bool {
    return x.count == y.count &&
        !zip(x, y).contains { $0 != $1 }
}

或者：

func compare(x: Array<Wallet>, y: Array<Wallet>) -> Bool {
    return x.elementsEqual(y, by: ==)
}

但是如果你输入Equatable，你就可以免费获得它（注意 您不必实现!=，这是自动提供的：

struct Wallet: Equatable {
    var fund = 0
    var name = ""

    public static func ==(lhs: Wallet, rhs: Wallet) -> Bool{
        return lhs.fund == rhs.fund && lhs.name == rhs.name
    }
}

现在您可以使用现有的

简单地将数组与 == 进行比较

func ==<Element>(lhs: Array<Element>, rhs: Array<Element>) -> Bool
 where Element : Equatable

操作员。