Question

我有这个方法

public static void primeSort( String[] list, HashMap< Integer, ArrayList< String >> hm ){

  for( int x=0; x<list.length; x++ ){
    if( list[ x ] == null ) continue;

    String curX    = list[ x ];
    int    hashX   = primeHash( curX );

    hm.put( hashX, new ArrayList( Arrays.asList( curX )));

    for( int y=x+1; y<list.length; y++ ){

      String curY    = list[ y ];
      int    hashY   = primeHash( curY );

      if( curY == null || curY.length() != curX.length())  continue;

      if( hashX == hashY ){
        hm.get( hashX ).add( curY );

        list[ y ] = null; // if its an anagram null it out to avoid checking again
      }
    }
  }
}

调用此方法：

public static int primeHash( String word ){
  int productOfPrimes = 1;
  int prime[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 
    37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101 };

  for( char ch : word.toCharArray() ){
    productOfPrimes *= prime[ (int) ch - (int) 'a' ];
  }
  return productOfPrimes;
}

目标是获取字符串列表并将它们分类为字谜，返回包含分组到列表中的字谜的列表。

我试图确定时间复杂度，但这有点棘手。 primeSort将是最坏情况O（n ^ 2）和最佳情况O（n）

primeHash每次调用m次，其中m是当前字符串的长度。我不确定如何分析它以及如何将其与primeSort的分析结合起来。

感谢任何帮助，谢谢：）

Answer 1

由于嵌套循环，它仅在第一个中O(n^2)。然后在每个循环中调用primeHash一次。那里你也有一个循环。设m为String字的长度。然后在WC中获得O((n*m)^2)。然而，m很可能是不同的，这就是为什么我采用最长的一个，比如M进行渐近分析。还O((n*M)^2)。假设WC中的M可以接近n：

你最终可以获得WC：O((n^2)^2) = O(n^4)。

在最好的情况下：第一个函数中只有一个循环迭代：O(n)。然后我们假设每个单词的长度。如果它们只有一个char，那么primehash中只有一个for循环迭代，或者只是常量。因此O(1)。

BC：O(n)。

依赖函数的时间复杂度

1 个答案: