如何计算这种复杂性？ #包括 #包括 int max（int A[]，int c，int d）； 内部主（空） { int i=0； int j=0； int A[3]={-95,52,3}； int B[3][3]； 对于（i=0；i

假设

n

表示

A

数组的大小以及

B

的两个维度，基本上有三个嵌套for循环，其中一个“外包”到

max

函数中

在最坏的情况下（当

c

为

0

且

d

为

n-1

时），它们中的每一个都通过

n

元素运行

---

因此，你的复杂性是O（n^3）因此，你有两个外部for循环（

i

和

j

），它们分别运行在

n

元素上。如果

jI认为它是O（n^3），因为
max
中也有循环。基本上你有
O（n²）
计算
max（）的复杂性
，所以总的来说是有意义的
O（n³）
正常。我是否可以对其进行优化，使其运行O（n^2）也许是USSR2101171，但是请把它作为一个单独的问题来解释。如果下面的答案之一是有用的，请把它标记为正确的。这应该作为你原来答案的一部分而添加，而不是作为一个单独的答案。好的艺术作品，但是你只能从我这里得到一张选票，这是另一个答案。（因为它是正确的，并且是最先提交的）@JonathanLeffler我决定将此作为一个单独的答案，因为经过再三考虑，我发现我的第一个答案并不令人满意。我现在确实想删除第一个，但因为它已被接受，所以不能删除。谢谢你的投票，尽管如此，一个已经足够了。实际上，我的论点不足以暗示O（n^3）假设有三个嵌套的for循环：
for i from 0 to n:for j from 0 to n:if（i==j）for k from 0 to n:do_something_O（1）；done；else:do_something_O（1）；endif；done；done；done
。对于此设置，您可以使用与我上面相同的参数，但复杂性是
O（n^2）+O（n）=O（n^2）
。需要进行更彻底的分析，例如，我在下面给出的分析。请停止投票，答案并不正确。谢谢。
#include <stdio.h>
#include <stdlib.h>
int max (int A[], int c, int d);

int main (void)
{
    int i = 0;
    int j = 0;
    int A[3] = {-95,52,3};
    int B[3][3];
    for( i = 0; i < 3; i++)
    {
        for(j = 0; j < 3; j++)
        {
            if(j < i)
            {
                B[i][j] = 0;
            }
            else
            {
                B[i][j] = max(A,i,j); 
            }
        }
    }



}

int max(int A[],int c,int d)
{
    int i = 0;
    int j = 0;
    int max = -100;

    for (i=c; i <= d; i++)
    {
        if(max < A[i])
        { 
            max = A[i];
        }
    }
    return max; 
}