Question

int I(int i, int j, int n) 
{ 
   return n * i + j;                                    >1
}
int DotProduct( int A[], int B[], int i, int j, int n )
{
   int t=0;                                             >1
   for(int k=0; k<n; k++ )                              > n+1              
      t += A[ I(i,k,n) ] * B[ I(k,j,n) ];               > n
   return t;                                            > n 
}
void MMultiply( int A[], int B[], int C[], int n ) 
{
   for( int i=0; i<n; i++ )                          > n+1
      for( int j=0; j<n; j++ )                       > (n)n+1
         C[ I(i,j,n) ] = DotProduct(A, B, i, j, n );  > see function above (n)(n)(3n+2)?
}

我不确定我是否应该在旧帖子或新帖子上发帖，因为这是紧急的（研究期中考试）

无论如何我知道大O是n ^ 3

（3n + 2）（n）（n）+（n + 1）（n）+（n + 1）＆lt;我做对了吗？

当老师教一些不在书上的东西时，我很讨厌！

Answer 1

简单方法：

计算嵌套循环的数量：N^3
计算操作次数：2（+，*）
完全是2N^3

Answer 2

你从一开始就开始：你首先需要计算一个平均情况下运行的时间MMultiply：

你在MMultiply中可以看到的第一件事是一个从0到n - 1的循环，它给你：

T（MMultiply）= n *（T（what_is_inside_the_first_loop））

现在你需要T（what_is_inside_the_first_loop）。因为你在第一个循环中只有另一个循环，所以T（what_is_inside_the_first_loop）= n * T（what_is_inside_the_second_loop）

第二个循环内部只有一个“DotProduct”调用，因此忽略“=”赋值，T（what_is_inside_the_second_loop）= T（DotProduct）。

要计算T（DotProduct），您可以逐行采用该功能：

1为初始分配
n for the loop
3（“+ =”操作为1，每次调用I为1 - 只执行一次操作）

所以T（DotProduct）= 1 + n * 3

在初始结果中替换T（DotProduct）可以得到：

T（MMultiply）= n * n *（1 + n * 3）= 3 * n ^ 3 + n ^ 2

所以

T（MMultiply）= 3 * n ^ 3 + n ^ 2

大O符号基本上只是将这个时间分配给特定的类（这是近似值）。最接近“3 * n ^ 3 + n ^ 2”的类是n ^ 3（因为n ^ 3是最重要的成员）。所以T（MMultiply）= O（n ^ 3）。

你的计算几乎是正确的，但你在MMultiply的前两行有一个“+ 1”盈余，如果你在每一行上评论处理该行所需的时间，“t + = A [I（I i，k，n）] * B [I（k，j，n）];“不取n，只需2。”返回t“相同，只需1。

算法分析大O和常规符号

2 个答案: