Arrays 从多维数组中删除重复项

我编写了以下扩展以从数组中删除重复项

extension Array where Element : Equatable{

    func removeDups() -> [Element]{
        var result = [Element]()

        for element in self{
            if !result.contains(element){
                result.append(element)
            }
        }

        return result
    }
}

线性阵列

let linearArr = [1,2,2,3]
linearArr.removeDups() // [1,2,3] works well!

let multiDimArr : [[Int]] = [[1,2,3], [1,2,3], [1,2 ,4]]
multiDimArr.removeDups() // Error!

多维数组

let linearArr = [1,2,2,3]
linearArr.removeDups() // [1,2,3] works well!

let multiDimArr : [[Int]] = [[1,2,3], [1,2,3], [1,2 ,4]]
multiDimArr.removeDups() // Error!

类型[Int]不符合Equatable

我读书。答案是使用

=

进行数组比较应该是可行的。它不是一直工作的：

有效

if (["1", "2"] == ["1", "2"]){
    print("true")
}

不起作用

if ([1, 2] == [1, 2]){ // ERROR!
    print("true")
}

运算符“==”的用法不明确

这很奇怪。我可以比较

String

s的数组，但不能比较

Int

s的数组

我还看到：

原因是

myArray1==myArray2

是

NSObject

符合equalable，调用

-[equals:][/code>进行测试

不确定☝️ 评论仍然有效

总结如下：


数组是否相等？我可以使用
==
为什么比较
String
s的数组与
Int
s的数组不同
如何从多维数组中删除重复项

我目前正在使用
swift4.0.2
这是递归可以解决问题的地方。你考虑过递归吗？我本来打算用实际代码回答这个问题，但我不知道Swift的语法。下面是一些伪代码：

function removeDupes() {
    buffer = array;
    foreach this->elements as key => element {             
         if(element is type array) {
              this->elements[key] = element->removeDupes();
         } else {
              if(!this->contains(element)) {
                  buffer->add(element);
              }
         }             
    }
    return buffer;
}

基本上，您需要测试元素本身是否是数组。如果是，那么您希望调用该数组的removeDupes（）方法（该方法反过来将查找重复项，除非它找到另一个数组，否则它将再次调用自身）。
这是递归可以解决问题的地方。你考虑过递归吗？我本来打算用实际代码回答这个问题，但我不知道Swift的语法。下面是一些伪代码：

function removeDupes() {
    buffer = array;
    foreach this->elements as key => element {             
         if(element is type array) {
              this->elements[key] = element->removeDupes();
         } else {
              if(!this->contains(element)) {
                  buffer->add(element);
              }
         }             
    }
    return buffer;
}

基本上，您需要测试元素本身是否是数组。如果是，那么您希望调用该数组的removeDupes（）方法（该方法将依次查找重复项，除非它找到另一个数组，否则它将再次调用自身）

数组是否相等？我可以使用
==

在Swift 4.1之前，
Array
不符合
equalable
。然而，有一个超负荷的
=
将两个数组与
相等的
元素进行了比较，这使它能够编译：

if ["1", "2"] == ["1", "2"] { // using <T : Equatable>(lhs: [T], rhs: [T]) -> Bool
    print("true")
}

不幸的是，这确实会导致一些代码重复，但至少在更新到4.1时您能够消除它

该示例未在4.0.3或4.1中编译：

if [1, 2] == [1, 2] { // error: Ambiguous use of operator '=='
    print("true")
}

是由错误引起的–编译器认为它是不明确的，因为
索引集
和
索引XPath
（两者都是
ExpressibleByArrayLiteral
）的重载。但是Swift应该将数组文本默认为
array
，以解决歧义

说：

if [1, 2] as [Int] == [1, 2] {
    print("true")
}

或者不导入
Foundation
解决问题


最后，值得注意的是，如果
元素
类型也是可散列的，允许它以线性时间而不是二次时间运行，则
removeDups（）的性能可以得到改进：

extension Array where Element : Hashable {

  func removeDups() -> [Element] {
    var uniquedElements = Set<Element>()
    return filter { uniquedElements.insert($0).inserted }
  }
}

扩展数组，其中元素：可哈希{
func removeDups（）->[元素]{
var uniquedElements=Set（）
返回筛选器{uniquedElements.insert（$0.inserted}
}
}

在这里，我们使用一个集合来存储我们看到的元素，省略了我们已经插入其中的任何元素。这也允许我们使用
过滤器（:）

而且，
数组
在其
元素
为
可散列
时也有条件地符合
可散列
：

Swift 4.2
[……]


标准库类型
可选
，
数组
，
数组片
，
连续数组
，
字典
，
字典侧向
，
范围
，以及
闭合范围
现在在其元素或绑定类型（视情况而定）符合
哈希
协议符合
哈希表
。这使得合成的
哈希实现可用于包含这些类型的存储属性的类型


数组是否相等？我可以使用
==

在Swift 4.1之前，
Array
不符合
equalable
。然而，有一个超负荷的
=
将两个数组与
相等的
元素进行了比较，这使它能够编译：

if ["1", "2"] == ["1", "2"] { // using <T : Equatable>(lhs: [T], rhs: [T]) -> Bool
    print("true")
}

不幸的是，这确实会导致一些代码重复，但至少在更新到4.1时您能够消除它

该示例未在4.0.3或4.1中编译：

if [1, 2] == [1, 2] { // error: Ambiguous use of operator '=='
    print("true")
}

是由错误引起的–编译器认为它是不明确的，因为
索引集
和
索引XPath
（两者都是
ExpressibleByArrayLiteral
）的重载。但是Swift应该将数组文本默认为
array
，以解决歧义

说：

if [1, 2] as [Int] == [1, 2] {
    print("true")
}

或者不导入
Foundation
解决问题


最后，值得注意的是，如果
元素
类型也是可散列的，允许它以线性时间而不是二次时间运行，则
removeDups（）的性能可以得到改进：

extension Array where Element : Hashable {

  func removeDups() -> [Element] {
    var uniquedElements = Set<Element>()
    return filter { uniquedElements.insert($0).inserted }
  }
}

扩展数组，其中元素：可哈希{
func removeDups（）->[元素]{
var uniquedElements=Set（）
返回筛选器{uniquedElements.insert（$0.inserted}
}
}

在这里，我们使用一个集合来存储我们看到的元素，省略了我们已经插入其中的任何元素。这也允许我们使用
过滤器（:）

而且，
数组
在其
元素
为
可散列
时也有条件地符合
可散列
：

Swift 4.2
[……]


标准