Algorithm 如何求算法的时间复杂度

问题

如何计算算法的时间复杂度

在发布问题之前我做了什么？

我已经通过了，和许多其他链接

但在哪里我都找不到一个关于如何计算时间复杂度的清晰而直接的解释

// Here c is a positive integer constant   
for (int i = 1; i <= n; i += c) {  
    // some O(1) expressions
}

for (int i = n; i > 0; i -= c) {
    // some O(1) expressions
}

我知道什么？

对于下面这样简单的代码：

char h = 'y'; // This will be executed 1 time
int abc = 0; // This will be executed 1 time

对于下面这样的循环：

for (int i = 0; i < N; i++) {        
    Console.Write('Hello World !');
}

for（inti=0；i

inti=0这将只执行一次。 时间实际计算为

i=0

，而不是声明

i这将执行N+1次

i++这将执行N次

因此，该循环所需的操作数为

{1+（N+1）+N}=2N+2

注意：这可能仍然是错误的，因为我对自己对计算时间复杂性的理解没有信心

for (int i = 1; i <=n; i += c) {
   for (int j = 1; j <=n; j += c) {
      // some O(1) expressions
   }
}

for (int i = n; i > 0; i += c) {
   for (int j = i+1; j <=n; j += c) {
      // some O(1) expressions
}

我想知道什么？

好的，这些小的基本计算我想我知道，但在大多数情况下，我认为时间复杂性

O（N）、O（n2）、O（对数N）、O（N！）。。。。还有很多,

有人能帮我理解一个算法的时间复杂度是如何计算的吗？我相信有很多像我这样的新手想知道这一点

如何求算法的时间复杂度

将它将执行多少机器指令作为输入大小的函数相加，然后将表达式简化为最大项（当N非常大时），可以包括任何简化常数因子

例如，让我们看看如何简化

2N+2

机器指令，将其描述为

O（N）

为什么要删除这两个

2

s？

当N变大时，我们对算法的性能感兴趣

考虑两个术语2N和2

当N变大时，这两项的相对影响是什么？假设N是一百万

那么第一期是200万，第二期只有2万

出于这个原因，除了大N的最大项外，我们放弃了所有项

所以，现在我们已经从

2N+2

到

2N

传统上，我们只对恒定因素下的性能感兴趣

这意味着，当N较大时，我们并不真正关心是否存在性能差异的常数倍数。2N的单位一开始并没有很好的定义。所以我们可以乘以或除以一个常数因子得到最简单的表达式

---

所以

2N

变成了

N

这是一篇优秀的文章：

下面的答案是从上面复制的（以防优秀链接失败）

计算时间复杂度最常用的度量是大O表示法。这将删除所有常数因子，以便当N接近无穷大时，可以根据N估计运行时间。一般来说，你可以这样想：

statement;

是恒定的。语句的运行时间不会因N而改变

for ( i = 0; i < N; i++ )
     statement;

是N*log（N）。运行时间由N个对数循环（迭代或递归）组成，因此该算法是线性和对数的组合

一般来说，用一维中的每一项做某事是线性的，用二维中的每一项做某事是二次的，将工作区域一分为二是对数的。还有其他大O度量，如立方、指数和平方根，但它们并不常见。大O表示法被描述为

O（）

，其中

是度量值。快速排序算法将被描述为

O（N*log（N））

请注意，所有这些都没有考虑最佳、平均和最坏情况度量。每个都有自己的大O符号。还要注意，这是一个非常简单的解释。大O是最常见的，但它也比我展示的更复杂。还有其他符号，如大ω、小o和大θ。在算法分析课程之外，您可能不会遇到这些问题

O（n）是用于编写算法时间复杂度的大O符号。当你把一个算法的执行次数加起来，你会得到一个表达式，比如2N+2，在这个表达式中，N是主要的项（如果它的值增加或减少，这个项对表达式的影响最大）。现在O（N）是时间复杂度，而N是支配项。 范例

表示i=1到n；
j=0；
而（j取自此处-

1.导言
在计算机科学中，算法的时间复杂度将算法运行所需的时间量化为表示输入的字符串长度的函数

2.大O符号
算法的时间复杂度通常用大O表示法表示，大O表示法不包括系数和低阶项。用这种方式表示时，时间复杂度称为渐近描述的，即当输入大小变为无穷大时

例如，如果一个算法对大小为n的所有输入所需的时间最多为5n3+3n，则渐近时间复杂度为O（n3）。稍后将对此进行详细说明

再举几个例子：


1=O（n）
n=O（n2）
对数（n）=O（n）
2 n+1=O（n）

3.O（1）恒定时间：
如果一个算法无论输入大小都需要相同的时间量，则称其在恒定时间内运行

示例：


数组：访问任何元素
固定大小堆栈：推送和弹出方法
固定大小队列：入队列和出队列方法

4.O（n）线性时间
如果算法的执行时间是线性的，则称其为线性时间
void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

For i= 1 to n;
  j= 0;
while(j<=n);
  j=j+1;

int find = 66;
var numbers = new int[] { 33, 435, 36, 37, 43, 45, 66, 656, 2232 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    if(find == numbers[i])
    {
        return;
    }
}

read(x)                               // O(1)
a = 10;                               // O(1)
a = 1.000.000.000.000.000.000         // O(1)

age = read(x)                               // (1+1) = 2
if age < 17 then begin                      // 1
      status = "Not allowed!";              // 1
end else begin
      status = "Welcome! Please come in";   // 1
      visitors = visitors + 1;              // 1+1 = 2
end;

total = 0;                                  // 1
for i = 1 to n do begin                     // (1+1)*n = 2n
      total = total + i;                    // (1+1)*n = 2n
end;
writeln(total);                             // 1

for i = 1 to n do begin                     // (1+1)*n  = 2n
   for j = 1 to n do begin                  // (1+1)n*n = 2n^2
       x = x + 1;                           // (1+1)n*n = 2n^2
       print(x);                            // (n*n)    = n^2
   end;
end;

V_k = 'That's the way,' U 'I like it, ' U
U   = 'uh huh,' 'uh huh'

// Here c is a positive integer constant   
for (int i = 1; i <= n; i += c) {  
    // some O(1) expressions
}

for (int i = n; i > 0; i -= c) {
    // some O(1) expressions
}

for (int i = 1; i <=n; i += c) {
   for (int j = 1; j <=n; j += c) {
      // some O(1) expressions
   }
}

for (int i = n; i > 0; i += c) {
   for (int j = i+1; j <=n; j += c) {
      // some O(1) expressions
}

for (int i = 1; i <=n; i *= c) {
   // some O(1) expressions
}
for (int i = n; i > 0; i /= c) {
   // some O(1) expressions
}

// Here c is a constant greater than 1   
for (int i = 2; i <=n; i = pow(i, c)) { 
   // some O(1) expressions
}
//Here fun is sqrt or cuberoot or any other constant root
for (int i = n; i > 0; i = fun(i)) { 
   // some O(1) expressions
}

int fun(int n)
{    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j < n; j += i)
        {
            // Some O(1) task
        }
    }    
}

int p = 0;
for (int i = 1; i < N; i++)
  p = p + 2;

int x = 0;
for (int i = 0; i < N; i++)
   for (int j = 0; j < N; j++)
      for (int k = 0; k < N; k++)
          x = x + 2