Arrays 如何提高代码的速度？

如果arrayOfA中的元素数约为1000，arrayOfB中的元素数约为100000（运行时间约为几分钟），则下面的代码存在速度问题。如何提高速度

let arrayOfA = [(String, String)]() //second string in tuple is about 30 characters 
let arrayOfB = [String]() //string is about 200 characters 
var arrayOfC = [(String, Int)]()

for i in 0..<arrayOfA.count
{
     var amount = Int()
     let name = arrayOfA[i].0 + "  " + arrayOfA[i].1

     for j in 0..<arrayOfB.count
     {
         if arrayOfB[j].range(of: arrayOfA[i].1) != nil
         {
             amount += 1
         } 
     }
     if amount > 0
     {
         arrayOfC += [(name, amount)]
     }
}

你可以试试这个

for i in 0..<arrayOfA.count {
        var amount = Int()
        let name = arrayOfA[i].0 + "  " + arrayOfA[i].1

        let tempArr = arrayOfB.filter { (string) -> Bool in
            string.rangeOfString(arrayOfA[i].1) != nil
        }
        amount = tempArr.count

        if amount > 0 {
            arrayOfC += [(name, amount)]
        }
    }
     arrayOfC += [(name, amount)]
 }

0中的i的

。。博伊尔
string.rangeOfString（arrayOfA[i].1）！=无
}
金额=tempArr.count
如果金额>0{
arrayOfC+=[（名称、金额）]
}
}
arrayOfC+=[（名称、金额）]
}

---

在任何情况下，过滤器都应该比for循环更有效。

这是使用建议注释更改后的代码

let arrayOfA = [(String, String)]() //second string in tuple is about 30 characters 
let arrayOfB = [String]() //string is about 200 characters 
var arrayOfC = [(String, Int)]()

for i in 0..<arrayOfA.count
{
     var amount = Int()

     for (index, stringB) in arrayOfB.enumerate().reverse()
     {
         if stringB.range(of: arrayOfA[i].1) != nil
         {
             amount += 1
             arrayOfB.removeAtIndex(index)
         } 
     }
     if amount > 0
     {
         let name = arrayOfA[i].0 + "  " + arrayOfA[i].1
         arrayOfC += [(name, amount)]
     }
}

let arrayOfA=[（String，String）]（）//元组中的第二个字符串约为30个字符
让arrayOfB=[String]（）//字符串约为200个字符
var arrayOfC=[（字符串，Int）]（）
因为我在0。。0
{
让name=arrayOfA[i].0+“”+arrayOfA[i].1
arrayOfC+=[（名称、金额）]
}
}

更新

在不反转阵列的情况下实现相同的功能

let arrayOfA = [(String, String)]() //second string in tuple is about 30 characters 
    let arrayOfB = [String]() //string is about 200 characters 
    var arrayOfC = [(String, Int)]()

for i in 0..<arrayOfA.count
{
     var amount = Int()
     var indexesToDelete = []
     for (index, stringB) in arrayOfB.enumerate()
     {
         if stringB.range(of: arrayOfA[i].1) != nil
         {
             amount += 1
             indexesToDelete.append(index)
         } 
     }

     for (index, indexToDelete) in indexesToDelete {
         arrayOfB.removeAtIndex(indexToDelete - index)
     }

     if amount > 0
     {
         let name = arrayOfA[i].0 + "  " + arrayOfA[i].1
         arrayOfC += [(name, amount)]
     }
}

let arrayOfA=[（String，String）]（）//元组中的第二个字符串约为30个字符
让arrayOfB=[String]（）//字符串约为200个字符
var arrayOfC=[（字符串，Int）]（）
因为我在0。。0
{
让name=arrayOfA[i].0+“”+arrayOfA[i].1
arrayOfC+=[（名称、金额）]
}
}

我认为您的操作没有那么复杂。优化可以减少持续时间，但不会太多。也许你可以使用线程来执行这样的操作。你能再解释一下数据是什么，以及你的代码试图实现什么吗？@Chris目标是找出arrayA中的每个字符串在arrayB中的字符串中可以找到多少次，并将其写入arrayC。你可以立即得到一个更快的算法，如果仅在必要时创建

名称

（也称为

if

的真实分支内）。stringB能否匹配多个stringA？如果没有，您可以将它们从arrayOfB中删除，这样下次您在arrayOfB上迭代时，其中的字符串将更少。您能证明筛选器比for循环更有效吗？过滤器应该做什么不同于迭代数组中的每个元素？实际上，这个概念似乎比OP的当前解决方案慢20%；我不明白你是如何更有效地衡量它的。。。谜团。@Yannick-过滤器在最坏情况下的复杂性为O（n）。运行n次。@holex-怎么会慢20%呢？你是如何计算20%的？@MaxPevsner循环中的for在任何情况下都有O（n）。过滤器的平均和最佳案例复杂度是多少？为什么过滤器不运行n次？它必须迭代每个项目，不是吗？

let arrayOfA = [(String, String)]() //second string in tuple is about 30 characters 
    let arrayOfB = [String]() //string is about 200 characters 
    var arrayOfC = [(String, Int)]()

for i in 0..<arrayOfA.count
{
     var amount = Int()
     var indexesToDelete = []
     for (index, stringB) in arrayOfB.enumerate()
     {
         if stringB.range(of: arrayOfA[i].1) != nil
         {
             amount += 1
             indexesToDelete.append(index)
         } 
     }

     for (index, indexToDelete) in indexesToDelete {
         arrayOfB.removeAtIndex(indexToDelete - index)
     }

     if amount > 0
     {
         let name = arrayOfA[i].0 + "  " + arrayOfA[i].1
         arrayOfC += [(name, amount)]
     }
}