为什么此方法的时间复杂度为2 * O（n log n）+ O（m log m）？

Question

下面的代码尝试检查searchWords所有单词是否都出现在newsPaperWords 。 两个列表都可以包含重复项。 如果出现一个字N在次searchWords ，它必须出现至少n次newsPaperWords该方法返回true。 我以为时间复杂度是2*O(n) + O(m)但面试官告诉我这是2*O(n log n) + O(m log m) 。

/**
 * @param searchWords The words we're looking for. Can contain duplicates
 * @param newsPaperWords  The list to look into
 */
public boolean wordMatch(List<String> searchWords, List<String> newsPaperWords) {
    Map<String, Integer> searchWordCount = getWordCountMap(searchWords);
    Map<String, Integer> newspaperWordCount = getWordCountMap(newsPaperWords);
    for (Map.Entry<String, Integer> searchEntry : searchWordCount.entrySet()) {
        Integer occurrencesInNewspaper = newspaperWordCount.get(searchEntry.getKey());
        if (occurrencesInNewspaper == null || occurrencesInNewspaper < searchEntry.getValue()) {
            return false;
        }
    }
    return true;
}

private Map<String, Integer> getWordCountMap(List<String> words) {
    Map<String, Integer> result = new HashMap<>();
    for (String word : words) {
        Integer occurrencesThisWord = result.get(word);
        if (occurrencesThisWord == null) {
            result.put(word, 1);
        } else {
            result.put(word, occurrencesThisWord + 1);
        }
    }
    return result;
}

我看到它，该方法的时间复杂度是2*O(n) + O(m)即n个元素的数量searchWords和M元素的数量newsPaperWords ）：

• 方法getWordCountMap()的复杂度为O(n) ，即给定列表中元素的数量为n。 该方法循环一次列表，并假设对result.get(word)和result.put()的调用是O(1) 。
• 然后，最坏的情况是searchWordCount.entrySet()的迭代是O(n) ，再次假设对Hashmap.get()调用是O(1) 。

因此，只需添加O(n) + O(m)即可构建两个地图，并为最后的外观添加O(n) 。

看完这个答案 ，以O(n)最坏情况的复杂性HashMap.get()我能理解的复杂性getWordCountMap()上升到O(n*2n)和最终环路O(n*n) ，这将使总复杂度为O(n*2n) + O(m*2m) + O(n*n) 。

但是2*O(n log n) + O(m log m)呢？

Answer 1

由于JEP 180：用平衡树处理频繁的HashMap冲突 HashMap.get()操作的最坏情况是O(log n) 。 引用JEP 180：

基本思想是，一旦哈希存储桶中的项目数超过某个阈值，该存储桶就会从使用条目的链接列表切换到平衡树。 在高哈希冲突的情况下，这将改善从O（n）到O（log n）的最坏情况下的性能。

这将使getWordCountMap()方法成为O(n log n) 。

Answer 2

假设哈希图使用适当的哈希函数，则您推论出的复杂度是正确的。 对我来说，这种算法看起来像O（m + n） 。

---

我想您的面试官描述了解决此问题的另一种方法的复杂性，这比较耗时，但最终占用的空间更少。