Java 如何确定HashMap中方法的最坏情况复杂性？

我知道在平均

put（k，v）

和

get（v）

take

o（1）

中，他们最糟糕的情况是

o（n）

。那么

containsKey（v）

呢？ 以及如何确定以下各项的运行时间：

public void addOccurence(String word) { 
    if (hm.containsKey(word)){
          hm.put(word, hm.get(word)+1);
    }
    else {hm.put(word, 1); }
}

---

最坏的情况是

o（n^2）

，平均情况是

o（1）

最坏情况是O（N）。你在做两个或三个操作，每个操作都是最坏的O（N），所以你有3N仍然是O（N）。你没有做任何二次性质的事情。

最坏情况下的时间复杂度

hm.put（word，hm.get（word）+1）

是

O（N）

方法：假设由于过度冲突，您的hashMap变成了一个链表。因此

get（）

必须搜索整个链表，因此

O（N）

。类似地，

hm.put（）

将需要遍历链表以插入值。所以

O（N）+O（N）=O（2N）~=O（N）

即使对于insert，您不会遍历整个链表，那么

get（）

方法的时间复杂性也是

O（N）

。所以总数是O（N）。因此，在这两种情况下，最坏情况下的时间复杂度都是

O（N）

但其渐近下界为

O（1）

方法： 因为如果您的密钥分布均匀，那么

get（）

将具有

o（1）

时间复杂度，对于

insert

也是如此。因此，在渐近时间复杂度中导致

O（1）

。

O（N）不是最坏的情况。HashMap只声明有固定的工作时间。事实并非如此。当特殊阈值超过时，通常通过重新灰化贴图来保持恒定的工作时间。请查看内部HashMap方法：

hm.put(word, hm.get(word)+1) 

若大小大于阈值，则会发生完全重新灰化，其复杂性等于创建新的HashMap。所以最坏的情况是

O（新HashMap（oldMap））+O（N）

---

若您错误地重写了hashCode（）函数，使其具有纯分布，则可能会出现O（N）。对于默认实现，这是不可能发生的。唯一的危险是重新灰化。

最坏情况下的运行时不是

O（n^2）

，因为对于每个循环，您没有

O（n）

RT的嵌套循环。运行时将是O（n），因为您正在将来自

hm.put（word，hm.get（word）+1）

方法的RT添加到来自

hm.containsKey（word）

方法的RT。和

O（n）+O（n）=O（2n）

==>

O（n）

当然，最好的情况是字符串不在hashmap中，并且执行了

else（…）

语句，或者

O（1）

---

作为旁注，

containsKey（k）

方法基本上是一个

get（k）

方法，它根据键是否存在返回布尔值。另一方面，

get（k）

方法将实际返回键的值，假设该键存在于hashmap中。两者的运行时是相同的，因为它们基本上以相同的方式搜索hashmap。

O（2*n）=O（n）。常数乘数对大O渐近性没有影响。（还有，你在第一段中的意思是“最坏的情况”而不是“单词情况”？）谢谢！这对我来说更有意义

void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

public void addOccurence(String word) { 
    if (hm.containsKey(word)){ //Worst Case O(n)
        hm.put(word, hm.get(word)+1); //Worst case O(n)
    }
    else {hm.put(word, 1); }  //O(1) Runtime
}