最佳和最壞情況的復雜性

Question

請幫助我找到以下代碼的復雜性：

public static int method(int[] array, int n) {
     for (i = 1; i < n; i++)
         for (j = 1; j <= i; j++)
            if (array[j] < array[j+1])
               for (k = 1; k <= n; k++)
                    array[k] = array[k] * 2;
}

我需要知道以這種代碼為例，在最佳和最差情況下如何計算BIG-O

Answer 1

最好的情況是O（n ^ 2），最壞的情況是O（n ^ 3）。

外部2循環無論執行什么。

第一個循環運行i = 1至n。 它執行n次。

第二個循環運行j = 1到i 。 它執行n *（n-1）/ 2次，這使其

為O（n ^ 2）。

第三個循環在if語句后面。 因此，在最佳情況下，它永遠不會執行，而在最壞情況下，它始終會執行。 對於第二個循環的每次執行，第三個循環執行n次。

因此，O（n ^ 3）是最壞的情況（如果每次都為true）。

假設n為11；

第一個循環執行10次。

第二個循環執行（1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10）次，即10 * 9/2 = 45次。

這是1/2 * 10 ^ 2-5-> O（n ^ 2），因為二次函數最大。

如果始終取值為true，則執行最里面的循環：

45＆10倍= 450 = 1/2 * 10 ^ 3-50-> O（n ^ 3），三次方最大。

Answer 2

對於此類問題，您最好的辦法就是畫一張桌子。
令n為某個數字，並且由於最壞的情況 ，假設始終滿足if ：

  i  |  j  |  k
-----+-----+-----
  1  |  1  |  1
  1  |  1  |  2
  1  |  1  | ...
  1  |  1  |  n
  2  |  1  |  1
  2  |  1  |  2 
  2  |  1  | ...
  2  |  2  |  n
  2  |  2  |  1
  2  |  2  |  2
  2  |  2  | ...
  2  |  2  |  n
 ..  | ..  |  ..

如果繼續執行此操作，您將直觀了解“取決於n的內部循環執行了多少次”，並且得到的是O（n ³ ）-我強烈建議您為表填充更多的值為了更好地理解什么是復雜性。

在最佳情況下，您將假設相反的情況（ if從不滿足），因此您將獲得一個簡單的嵌套循環，即O（n ² ）。

Answer 3

O（n ^ 2）最佳情況：用於反向排序的數組； 和

O（n ^ 3）最壞的情況：用於排序數組。

另外一些注意事項：

Java中的數組是零索引的。 通常將計數器初始化為1是不正確的做法，應將它們初始化為0； 否則，您可能會無意間跳過array[0] 。

如果曾經array.length == n ，您將獲得2 ArrayIndexOutOfBoundsException s：

（第1個）在array[j+1]當j==i==n-1

（2nd）當k==n時在array[k] 。

如果array[j] array.length < n ，則將獲得另一個ArrayIndexOutOfBoundsException 。