分析算法的最佳，最差和平均情况

Question

我想知道find和replaceAll方法的最佳，最差和平均情况是什么，下面的代码中的增长函数基本上是在每种情况下数组大小大于零的情况下执行的语句数

/**
 * Return index where value is found in array or -1 if not found.
 * @param array ints where value may be found
 * @param value int that may be in array
 * @return index where value is found or -1 if not found
 */
public static int find(int[] array, int value) {
    for (int i = 0; i < array.length; i++) {
        if (array[i] == value) {
            return i;
        }
    }
    return -1;
}

/**
 * Replace all occurrences of oldValue with newValue in array.
 * @param array ints where oldValue may be found
 * @param oldValue value to replace
 * @param newValue new value
 */
public static void replaceAll(int[] array, int oldValue, int newValue) {
    int index = find(array, oldValue);
    while (index > -1) {
        array[index] = newValue;
        index = find(array, oldValue);
    }
}

Answer 1

这是用于find（...）方法的

您很容易知道最好和最坏的情况：

最好的情况是，要搜索的元素是数组中的第一个元素。在这种情况下，只需花费1次迭代即可找到您的元素，O(1)恒定时间。

类似地，最坏的情况是要搜索的元素不存在于数组中，因此您遍历整个数组只是找不到任何东西。在这种情况下，它需要进行n次迭代（其中n是数组的大小），O(n)个线性时间。

在大多数情况下，很容易确定最坏的情况。您可以简单地查看嵌套循环。如果您有x个嵌套循环，其中所有循环都以线性时间遍历整个数组，那么您的时间复杂度为O（n ^ x）。因此，在replaceAll（...）中，您有2个嵌套循环（来自while方法的for和find(...)），这意味着{{1 }}

对于一般情况：

我为您的O(n^2)函数编写了一个测试：

replaceAll(...)

上面的代码测试您的find函数100,000次。它计算平均迭代次数，每次运行时通常约为25次。使用大小为100的数组，平均进行25次迭代以查找要搜索的元素。得出find(...)，其中n =数组的大小，在这种情况下为100。这与O（n）（Why to ignore the constants in computing the running time complexity of an Algorithm）一样好。因此，您的public static void main(String[] args) { int iterationsTotal = 0; int timesTested = 100000; //Test 1000 times for(int i = 0; i < timesTested; i++) { int n = 100; //Array size to test int[] array = new int[n]; //Populate the array int j = 0; for(j = 0; j < array.length; j++) { array[j] = (int)(Math.random() * 100); } //You can search for any number, even 99. It will always result in 25 average. iterationsTotal += find(array, 5); } System.out.println(iterationsTotal / timesTested); } 算法的平均情况为O（n）。您可以对O(n/4)

做同样的事情

Answer 2

查找

• 充其量我们可以在第一个点找到所需的序列，因此：Ω（1）
• 在最坏的情况下，最后找到所需序列的原因是： O（n）
• 平均值：Θ（n）

全部替换

• 在最坏的情况下，这将是 O（n ^ 2），因为它需要搜索所有字符以找到所需的替换。

增长功能？

• 上面的代码中没有任何增长方法，因此我将为您提供复制数组的时间复杂度。 所有情况都是线性的 O（n）。

我希望这会有所帮助。

Answer 3

您的运行时位于O(n^2)

• 最佳情况：该数组仅包含一个等于您要替换的值的项目。该项目也是数组中的第一项。以n次迭代运行
• 最坏的情况：阵列中的所有项目都等于您要替换的值。这将在n^2个迭代中运行

在O(n)中进行优化的简单方法

如果要在O(n)中进行创建，则在使用find时需要传递起始索引，这样就不必从数组的开头重复搜索

public static int find(int[] array, int value, int start) {
    for (int i = start; i < array.length; i++) {
        if (array[i] == value) {
            return i;
        }
    }
    return -1;
}

public static void replaceAll(int[] array, int oldValue, int newValue) {
    int index = find(array, oldValue);
    while (index > -1) {
        array[index] = newValue;
        index = find(array, oldValue, index);
    }
}