Question

首先 - 是，我在SO上阅读了几篇文章，以及其他关于估算算法复杂性的地方。

我想尝试使用我编写的算法找到最大的矩形，看看我是否理解了我所阅读的内容。

public static long getLargestRectangle(long[] arr, int index, long max) {
    int count = 1;      //1 step * 1                               
    int i = index - 1;   //1 step * 1
    int j = index + 1;  //1 step * 1

    if(index == arr.length-1) return max; //1 step * 2

    while(i > -1 && arr[index] <= arr[i]) { //1 step * (N+1)
        count++;                             //1 step * N
        i--;                                 //1 step * N
    }
    while(j <= arr.length-1 && arr[index] <= arr[j]) { //1 step * (N+1)
        count++;                                        //1 step * N
        j++;                                            //1 step * N
    }

    max = (max < (arr[index] * count) ? (arr[index] * count) : max); //1 step * 7

    return getLargestRectangle(arr, index + 1, max); //1 step * 1
}

    //total number of steps: 1 + 1 + 1 + (N + 1) + N + N + (N + 1) + N + N + 7 
    //=> 6N + 12 = O(N) ?

我离开这里了吗？我喜欢一些见解。

编辑

喜欢这个吗？

T(n) = O(N) + T(n+1)
T(n) = O(N) + O(N) + T(n+2)
T(n) = O(N) + O(N) + O(N) + T(n+3)
T(n) = i * O(N) + (n+i)
T(n) = n * O(N) + (n+n)
= O(N^2)

如果这是错的，我真的很感激你是否可以更新你的答案并告诉我。

Answer 1

我离开这里了吗？我喜欢一些见解。

我很害怕:(

return getLargestRectangle(arr, index + 1, max); //1 step * 1

以上不是一步，它是该方法的递归调用。此方法将数组“缩小”1个元素，因此此步骤实际上花费T(n-1)，其中T(.)是算法的时间复杂度。
结合你已经拥有的东西，你得到了

T(n) = T(n-1) + O(N)

解决此递推公式将为您提供算法的复杂性。

注意：T(n) = T(n-1) + O(N)是一个合成糖，对于某个常量T(n) <= T(n-1) + CONST*N实际上应该是CONST，因为你不能在标量中添加一个集合（O(N)）（T(n-1)）。

另请注意：N!=n。 n随时间变化，N是数组的初始长度。之所以如此，是因为您的算法实际上是从n（index）到0，从n到N。
然而，这并没有改变大O符号的时间复杂度。

使用步数查找算法的复杂性

1 个答案: