Question

我有一个长度相同的单词的hashset。我想找到这个hashset中存在的所有字谜并将它们收集到另一个名为anagrams的hashset中。这是循环：

public HashSet<String> getUniqueAnagramsSlow(HashSet<String> paddedWords, int areAnagramsVersion){
    HashSet<String> anagrams = new HashSet<String>(); 
    Object[] paddedWordsArr = paddedWords.toArray();
    for(int i = 0; i < paddedWordsArr.length-1; i++){
        boolean foundAnagram = false;
        String wordOne = (String) paddedWordsArr[i];
        if(!anagrams.contains(wordOne)) 
            for(int j = i+1; j < paddedWordsArr.length; j++){
                String wordTwo = (String) paddedWordsArr[j];
                if(areAnagrams(wordOne, wordTwo, areAnagramsVersion)){
                    foundAnagram = true;
                    anagrams.add(wordTwo);
                }
            }
        if(foundAnagram){
            anagrams.add(wordOne);
        }
    }
    return anagrams;
}

我编写此代码的目的是了解不同的areAnagram（）函数如何影响运行时。我写了两个版本的areAnagrams（）。一个对两个字符串进行排序并将它们进行比较，另一个使用散列图来比较字符频率。他们在这里：

public boolean areAnagramsVersionOne(String first, String second){
    char[] arr1 = first.toCharArray();
    Arrays.sort(arr1);
    String fSorted = new String( arr1 );
    char[] arr2 = second.toCharArray();
    Arrays.sort(arr2);
    String sSorted = new String(arr2);
    return fSorted.equals(sSorted);
}
public boolean areAnagramsVersionTwo(String first, String second){
    HashMap<String, Integer> wordOne = new HashMap<String,Integer>();
    for(int i = 0; i < first.length(); i++){
        String letOne = first.substring(i, i+1);
        if(wordOne.containsKey(letOne)){
            int letOneFreq = wordOne.get(letOne);
            wordOne.put(letOne, letOneFreq + 1);
        }else{
            wordOne.put(letOne, 1);
        }
    }
    for(int i = 0; i < second.length(); i++){
        String letTwo = second.substring(i, i+1);
        if(!wordOne.containsKey(letTwo))
            return false;
        int freq = wordOne.get(letTwo);
        if(freq == 0)
            return false;
        wordOne.put(letTwo, freq-1);
    }
    return true;
}

根据我的理解，areAnagramsVersionOne（）将在NlogN时间内运行，而areAnagramsVersionTwo（）将在N时间内运行。但是，当我在原始循环中测试这两个版本的anagrams时，版本2明显变慢了。这是为什么？

谢谢。

这是我测试运行时的一个例子：

long startTime = System.currentTimeMillis();
getUniqueAnagramsSlow(words, 2);
long endTime = System.currentTimeMillis();
System.out.println("exec time: " + (endTime - startTime) );

Answer 1

据我所知，O（NlogN）仅保证大于O（N）对于足够大的N值，因为在小值时，O（）表示法中未表示的系数和常数仍然相关。考虑2种算法，使其成本为：

算法1成本：100 * N：O（N）

算法2成本：10 * NlogN：O（NlogN）

O（NlogN）＆gt; O（N）=＆gt; 10 * NlogN＆gt; 100 * N =＆gt; 10 * logN＆gt; 100 =＆gt; logN＆gt; 10

因此，在这种情况下，当N> 1时，算法2将比算法1花费更多。 2 ^ 10。对于较小的值，算法2的成本较低，即使它的效率较低＆＃34;根据O（）表示法。

阅读the wikipedia page for O() notation了解详情。

为什么我的O（NLogN）算法找到字谜比我的O（N）算法运行得更快？

1 个答案: