Swift - 性能方面 - 比较两个数组并获得每个数组的差异和两者的共同点

Question

希望你今天过得愉快。

我正在尝试了解执行以下操作的最快方法是什么：

假设我有这两个Arrays:

var firstArray = ["a","b","c"]
var secondArray = ["a","d","e"]

我想得到一个输出：

1)Array 内部 firstArray 但没有 secondArray 的对象。
1)Array 内部 secondArray 但没有 firstArray 的对象。
3)Array 属于firstArray 和secondArray 之间的common 对象。

所以基本上输出是：

1) ["b","c"]
2) ["d","e"]
3）["a"]

这里的主要问题是了解这样做的最有效方法是什么。非常感谢！

Answer 1

如果您的数组已排序并且每个数组中的项目都是唯一的，那么最快的方法是只处理每个项目一次。首先比较每个数组中的第一项；如果它们相等，则将其放入公共数组中，然后转到第二个项目。如果一个项目小于另一个，它将进入较小项目的唯一数组，然后您继续移动到较小数组中的下一个项目。继续此过程，直到您用完一个数组的项，然后将第二个数组的剩余项放入该数组的唯一项数组中。

var i = 0
var j = 0

let a = ["a", "b", "c"]
let b = ["a", "d", "e"]

var aUnique = [String]()
var bUnique = [String]()
var common = [String]()

while i < a.count && j < b.count {
    if a[i] == b[j] {
        common.append(a[i])
        i += 1
        j += 1
    } else if a[i] < b[j] {
        aUnique.append(a[i])
        i += 1
    } else {
        bUnique.append(b[j])
        j += 1
    }
}

if i < a.count {
    // put remaining items into aUnique
    aUnique += a[i ..< a.count]
} else if j < b.count {
    // put remaining items into bUnique
    bUnique += b[j ..< b.count]
}

print(common)  // ["a"]
print(aUnique) // ["b", "c"]
print(bUnique) // ["d", "e"]

---

分析

• 此算法每次通过循环将一项附加到数组之一。如果两个数组相对于彼此是唯一的，或者只有它们的最后一项是共同的，它将最多循环a.count + b.count - 1 次。
• 如果两个数组相同，它将仅循环a.count 次。
• 如果数组b 的所有元素都大于数组a 的元素，它将只循环a.count 次。如果数组a的所有元素都大于数组b的元素，则只会循环b.count次。

Answer 2

我假设你的数组元素是Equatable。

如果它们也是Hashable，并且元素的顺序对您来说并不重要，并且如果（如您的示例中）所有元素都是唯一的，您可能需要考虑使用集合代数而不是有序集合类型，例如Array。例如。在 Swift 中使用 Set 允许您对 1) 和 2) 使用 subtract(_:) 或 subtracting(_:) mutating/non-methods，对于 3) 使用 intersection(_:)/formIntersection(_:)，它们都使用 O(1) (摊销）查找用于比较集合之间的元素（与例如使用 O(n) contains(_:) of Array（带有Equatable元素）来查找某些指定元素的存在相比）。

更多详细信息，请参阅language reference for Set 以及 vadian 链接到的线程：

• Set operations (union, intersection) on Swift array?

---

如果每个数组中的元素不是唯一的，并且您希望保留多个元素以及元素之间的顺序，则可以使用其中一个数组的 Set 表示，同时过滤另一个数组。

例如，对于：

var firstArray = ["a","b","c"]
var secondArray = ["a","d","e"]

A) 在O(n):

let excludeElements = Set(secondArray)        // O(n)
secondArray = secondArray
    .filter { !excludeElements.contains($0) } // O(n) due to O(1) (amortized) .contains lookup

B) 在O(n):

let excludeElements = Set(firstArray)         // O(n)
secondArray = secondArray
    .filter { !excludeElements.contains($0) } // O(n) due to O(1) (amortized) .contains lookup

C) 在O(n) 中，使用在firstArray 中出现的顺序和重复：

let includeElements = Set(secondArray)  // O(n)
let commonElements = firstArray
    .filter(includeElements.contains)   // O(n) due to O(1) (amortized) .contains lookup

C) 在O(n) 中，使用在secondArray 中出现的顺序和重复：

let includeElements = Set(firstArray) // O(n)
let commonElements = secondArray
    .filter(includeElements.contains) // O(n) due to O(1) (amortized) .contains lookup

---

性能？

上面只考虑了渐近时间复杂度，并没有考虑任何实际的基准测试。通常，诸如 filter 之类的函数方法比 for 或 while 循环要慢，因此 如果 性能成为您的应用程序的问题，此时您应该考虑执行分析以及自定义基准测试算法中可能存在的瓶颈。

此外，如果已知您的数组已排序，则有更有效的方法可以遍历它们并过滤掉结果。参见例如以下线程（C语言，但逻辑是重要部分）：

• Finding common elements in two arrays of different size