Java 使用两个hashmap是否会生成一个算法O（n平方）？

我试图找出下面算法的时间和空间复杂度

我认为时间复杂度是O（n），其中n是较大HashMap的大小。我的理解是，这3个循环使它成为O（3n），然后你去掉常数得到O（n）。HashMaps（至少在Java中）是put和get操作的O（1）

我认为空间复杂度是O（n），其中n是HashMap的大小

这是我的问题。有两个哈希映射。那么，这是否使得空间复杂度nxn=n平方

或者是O（2n），它变成了O（n）

HashMap magazinewordoccurrencess=newhashmap（）；
对于（int i=0；i=notewordocations.get（key）））
{
匹配=假；
系统输出打印项次（“否”）；
打破
}
}
其他的
{
匹配=假；
系统输出打印项次（“否”）；
打破
}
}
如果（匹配）
{
System.out.println（“是”）；
}
有两个
HashMap
并不重要

重要的是你有3个循环，它们不是嵌套的。每个循环的迭代需要固定的时间，因此每个循环的整个运行时间取决于迭代次数

因此，总运行时间为O（n），其中
n
是
杂志.长度
，
注释.长度
和
注释单词引用.键集（）.大小（）
中的最大值

空间复杂性也是线性的，只要你有固定数量的数据结构（在你的例子中有2个
Map
s），并且每一个结构都需要
O（n）
空间。
谢谢，我很感激。复杂性与循环的数量无关，而与所做的工作量有关！
HashMap<String,Integer> magazineWordOccurrences = new HashMap<String, Integer>();
for (int i = 0; i < magazine.length; i++)
{
    if (magazineWordOccurrences.containsKey(magazine[i]))
    {
        magazineWordOccurrences.put(magazine[i], magazineWordOccurrences.get(magazine[i]) + 1);
    }
    else
    {
        magazineWordOccurrences.put(magazine[i], 1);
    }
}

HashMap<String,Integer> noteWordOccurrences = new HashMap<String, Integer>();
for (int i = 0; i < note.length; i++)
{
    if (noteWordOccurrences.containsKey(note[i]))
    {
        noteWordOccurrences.put(note[i], noteWordOccurrences.get(note[i]) + 1);
    }
    else
    {
        noteWordOccurrences.put(note[i], 1);
    }
}

boolean match = true;
for (String key: noteWordOccurrences.keySet())
{
    if (magazineWordOccurrences.containsKey(key))
    {
        if (!(magazineWordOccurrences.get(key) >= noteWordOccurrences.get(key)))
        {
            match = false;
            System.out.println("No");
            break;
        }
    }
    else
    {
        match = false;
        System.out.println("No");
        break;
    }
}

if (match)
{
    System.out.println("Yes");
}