Javascript 获取时间复杂性

我写了这个算法。你能帮我计算一下“时间复杂度”吗？ 我没有嵌套函数，但有.includes内部映射

function prime(num) {
  for (var i = 2; i < num; i++) if (num % i === 0) return false;
  return num > 1;
}

const function = (dataA, dataB) => {
  let temp = {};
  let tempArray = [];
  dataB.forEach(function (x) {
    temp[x] = (temp[x] || 0) + 1;
  });
  dataA.map(item => {
    if (dataB.includes(item) && !prime(temp[item])) {
      tempArray.push(item);
    } else if (!dataB.includes(item)) {
      tempArray.push(item);
    }
  });
  return tempArray;
};

console.log('Input A:', A);
console.log('Input B:', B);
console.log('Output:', function(A, B));

函数素数（num）{
对于（var i=2；i1；
}
常量函数=（数据A，数据B）=>{
设temp={}；
设tempArray=[]；
forEach（函数（x）{
温度[x]=（温度[x]| 0）+1；
});
dataA.map（项=>{
if（数据包括（项目）和&！素数（临时[项目]）{
tempArray.push（项目）；
}如果（！数据包括（项目））则为else{
tempArray.push（项目）；
}
});
返回数组；
};
log（'Input A:'，A）；
log（'Input B:'，B）；
log（'Output:'，函数（A，B））；

您的

isPrime

函数的最坏时间复杂度为O（n）

forEach

函数是一个单独的O（n）函数

map

函数对

dataA

中的每个项目进行评估，并在每个

中执行O（n）操作，该函数包括
和
isPrime
函数

因此，总时间复杂度为O（n^2）。
一些观察结果：


B.includes
的时间复杂度为O（
B.length
）


isPrime
的时间复杂度为O（
num
）。由于参数是B中某个值的频率，它受B的大小限制，因此它的最坏情况是O（
B.length
），因为只有在调用
B.includes
时才调用
isPrime
，因此它与总体时间复杂度无关


由于
B.includes
的调用次数与A中的值相同，因此总体时间复杂度为O（
A.length*B.length
）



通过将
B.includes（item）
替换为
count[item]
，可以降低复杂性，然后
isPrime
将变为确定性。如果
isPrime
通过记忆扩展，则所有
isPrime
调用的总成本为O（
A.length+B.length
），因此这也是总体时间复杂度

这不能进一步减少，因为即使不调用
isPrime
，对两个输入数组的迭代也是必要的，并且已经代表了时间复杂性