https://www.cnblogs.com/TangBiao/p/5856695.html
 
https://blog.csdn.net/dazhaoDai/article/details/81631195
 
https://www.cnblogs.com/hengzhou/p/9896535.html
 
 
 
算法复杂度分析
 
为什么要进行算法分析？
 
预测算法所需的资源 
  
计算时间（CPU 消耗）
内存空间（RAM 消耗）
通信时间（带宽消耗）
预测算法的运行时间 
  
在给定输入规模时，所执行的基本操作数量。
或者称为算法复杂度（Algorithm Complexity）
如何衡量算法复杂度？
 
内存（Memory）
时间（Time）
指令的数量（Number of Steps）
特定操作的数量 
  
磁盘访问数量
网络包数量
渐进复杂度（Asymptotic Complexity）
算法的运行时间与什么相关？
 
取决于输入的数据。（例如：如果数据已经是排好序的，时间消耗可能会减少。）
取决于输入数据的规模。（例如：6 和 6 * 109）
取决于运行时间的上限。（因为运行时间的上限是对使用者的承诺。）
算法分析的种类：
 
最坏情况（Worst Case）：任意输入规模的最大运行时间。（Usually）
平均情况（Average Case）：任意输入规模的期待运行时间。（Sometimes）
最佳情况（Best Case）：通常最佳情况不会出现。（Bogus）
例如，在一个长度为 n 的列表中顺序搜索指定的值，则
 
最坏情况：n 次比较
平均情况：n/2 次比较
最佳情况：1 次比较
而实际中，我们一般仅考量算法在最坏情况下的运行情况，也就是对于规模为 n 的任何输入，算法的最长运行时间。这样做的理由是：
 
一个算法的最坏情况运行时间是在任何输入下运行时间的一个上界（Upper Bound）。
对于某些算法，最坏情况出现的较为频繁。
大体上看，平均情况通常与最坏情况一样差。
算法分析要保持大局观（Big Idea），其基本思路：
 
忽略掉那些依赖于机器的常量。
关注运行时间的增长趋势。
比如：T(n) = 73n3 + 29n3 + 8888 的趋势就相当于 T(n) = Θ(n3)。
 
渐近记号（Asymptotic Notation）通常有 O、 Θ 和 Ω 记号法。Θ 记号渐进地给出了一个函数的上界和下界，当只有渐近上界时使用 O 记号，当只有渐近下界时使用 Ω 记号。尽管技术上 Θ 记号较为准确，但通常仍然使用 O 记号表示。
 
使用 O 记号法（Big O Notation）表示最坏运行情况的上界。例如，
 
线性复杂度 O(n) 表示每个元素都要被处理一次。
平方复杂度 O(n2) 表示每个元素都要被处理 n 次。
Notation
Intuition
Informal Definition
 
f is bounded above by g asymptotically
 
 
 
 
Two definitions :
 Number theory:
 
f is not dominated by g asymptotically
 
Complexity theory:
 
f is bounded below by g asymptotically
 
 
 
 
f is bounded both above and below by g asymptotically
 
 
 
例如：
 
T(n) = O(n3) 等同于 T(n) ∈ O(n3)
T(n) = Θ(n3) 等同于 T(n) ∈ Θ(n3).
相当于:
 
T(n) 的渐近增长不快于 n3。
T(n) 的渐近增长与 n3 一样快。
复杂度
标记符号
描述
常量（Constant）
 
 O(1) 
 
 
操作的数量为常数，与输入的数据的规模无关。
 
n = 1,000,000 -> 1-2 operations 
 
对数（Logarithmic）
 
 O(log2 n) 
 
 
操作的数量与输入数据的规模 n 的比例是 log2 (n)。
 
n = 1,000,000 -> 30 operations
 
线性（Linear）
 O(n)
 
操作的数量与输入数据的规模 n 成正比。
 
n = 10,000 -> 5000 operations
 
平方（Quadratic）
 O(n2)
 
操作的数量与输入数据的规模 n 的比例为二次平方。
 
n = 500 -> 250,000 operations
 
立方（Cubic）
 O(n3)
 
操作的数量与输入数据的规模 n 的比例为三次方。
 
n = 200 -> 8,000,000 operations
 
指数（Exponential）
 
 O(2n)
 
 O(kn)
 
 O(n!)
 
 
指数级的操作，快速的增长。
 
n = 20 -> 1048576 operations
 
注1：快速的数学回忆，logab = y 其实就是 ay = b。所以，log24 = 2，因为 22 = 4。同样 log28 = 3，因为 23 = 8。我们说，log2n 的增长速度要慢于 n，因为当 n = 8 时，log2n = 3。
 
注2：通常将以 10 为底的对数叫做常用对数。为了简便，N 的常用对数 log10 N 简写做 lg N，例如 log10 5 记做 lg 5。
 
注3：通常将以无理数 e 为底的对数叫做自然对数。为了方便，N 的自然对数 loge N 简写做 ln N，例如 loge 3 记做 ln 3。
 
注4：在算法导论中，采用记号 lg n = log2 n ，也就是以 2 为底的对数。改变一个对数的底只是把对数的值改变了一个常数倍，所以当不在意这些常数因子时，我们将经常采用 "lg n"记号，就像使用 O 记号一样。计算机工作者常常认为对数的底取 2 最自然，因为很多算法和数据结构都涉及到对问题进行二分。
 
 
而通常时间复杂度与运行时间有一些常见的比例关系：
 
复杂度
10
20
50
100
1000
10000
100000
O(1)
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
O(log2(n))
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
O(n)
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
O(n*log2(n))
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
O(n2)
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
2s
 
 
3-4 min
 
O(n3)
 
<1s
 
 
<1s
 
 
<1s
 
 
<1s
 
 
20s
 
 
 5 hours 
 
 
 231 days 
 
O(2n)
 
<1s
 
 
<1s
 
 
 260 days 
 
 
 hangs 
 
 
 hangs 
 
 
hangs
 
 
hangs
 
O(n!)
 
<1s
 
 
 hangs 
 
 
hangs
 
 
 hangs 
 
 
hangs
 
 
hangs
 
 
hangs
 
O(nn)
 
 3-4 min 
 
 
hangs
 
 
hangs
 
 
 hangs 
 
 
hangs
 
 
hangs
 
 
hangs
 
计算代码块的渐进运行时间的方法有如下步骤：
 
确定决定算法运行时间的组成步骤。
找到执行该步骤的代码，标记为 1。
查看标记为 1 的代码的下一行代码。如果下一行代码是一个循环，则将标记 1 修改为 1 倍于循环的次数 1 * n。如果包含多个嵌套的循环，则将继续计算倍数，例如 1 * n * m。
找到标记到的最大的值，就是运行时间的最大值，即算法复杂度描述的上界。
示例代码（1）：
 
 
 
1     decimal Factorial(int n)
2     {
3       if (n == 0)
4         return 1;
5       else
6         return n * Factorial(n - 1);
7     }
 
 
 
阶乘（factorial），给定规模 n，算法基本步骤执行的数量为 n，所以算法复杂度为 O(n)。
 
示例代码（2）：
 
 
 
 1     int FindMaxElement(int[] array)
 2     {
 3       int max = array[0];
 4       for (int i = 0; i < array.Length; i++)
 5       {
 6         if (array[i] > max)
 7         {
 8           max = array[i];
 9         }
10       }
11       return max;
12     }
 
 
 
这里，n 为数组 array 的大小，则最坏情况下需要比较 n 次以得到最大值，所以算法复杂度为 O(n)。
 
示例代码（3）：
 
 
 
1     long FindInversions(int[] array)
2     {
3       long inversions = 0;
4       for (int i = 0; i < array.Length; i++)
5         for (int j = i + 1; j < array.Length; j++)
6           if (array[i] > array[j])
7             inversions++;
8       return inversions;
9     }
 
 
 
这里，n 为数组 array 的大小，则基本步骤的执行数量约为 n*(n-1)/2，所以算法复杂度为 O(n2)。
 
示例代码（4）：
 
 
 
1     long SumMN(int n, int m)
2     {
3       long sum = 0;
4       for (int x = 0; x < n; x++)
5         for (int y = 0; y < m; y++)
6           sum += x * y;
7       return sum;
8     }
 
 
 
给定规模 n 和 m，则基本步骤的执行数量为 n*m，所以算法复杂度为 O(n2)。
 
示例代码（5）：
 
 
 
1     decimal Sum3(int n)
2     {
3       decimal sum = 0;
4       for (int a = 0; a < n; a++)
5         for (int b = 0; b < n; b++)
6           for (int c = 0; c < n; c++)
7             sum += a * b * c;
8       return sum;
9     }
 
 
 
这里，给定规模 n，则基本步骤的执行数量约为 n*n*n ，所以算法复杂度为 O(n3)。
 
示例代码（6）：
 
 
 
1     decimal Calculation(int n)
2     {
3       decimal result = 0;
4       for (int i = 0; i < (1 << n); i++)
5         result += i;
6       return result;
7     }
 
 
 
这里，给定规模 n，则基本步骤的执行数量为 2n，所以算法复杂度为 O(2n)。
 
示例代码（7）：
 
斐波那契数列：
 
Fib(0) = 0
Fib(1) = 1
Fib(n) = Fib(n-1) + Fib(n-2)
F() = 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ...
 
 
 
1     int Fibonacci(int n)
2     {
3       if (n <= 1)
4         return n;
5       else
6         return Fibonacci(n - 1) + Fibonacci(n - 2);
7     }
 
 
 
这里，给定规模 n，计算 Fib(n) 所需的时间为计算 Fib(n-1) 的时间和计算 Fib(n-2) 的时间的和。
 
T(n<=1) = O(1)
 
T(n) = T(n-1) + T(n-2) + O(1)
 
                     fib(5)   
                 /             \     
           fib(4)                fib(3)   
         /      \                /     \
     fib(3)      fib(2)         fib(2)    fib(1)
    /     \        /    \       /    \  
 
通过使用递归树的结构描述可知算法复杂度为 O(2n)。
 
示例代码（8）：
 
 
 
 1     int Fibonacci(int n)
 2     {
 3       if (n <= 1)
 4         return n;
 5       else
 6       {
 7         int[] f = new int[n + 1];
 8         f[0] = 0;
 9         f[1] = 1;
10 
11         for (int i = 2; i <= n; i++)
12         {
13           f[i] = f[i - 1] + f[i - 2];
14         }
15 
16         return f[n];
17       }
18     }
 
 
 
同样是斐波那契数列，我们使用数组 f 来存储计算结果，这样算法复杂度优化为 O(n)。
 
示例代码（9）：
 
 
 
 1     int Fibonacci(int n)
 2     {
 3       if (n <= 1)
 4         return n;
 5       else
 6       {
 7         int iter1 = 0;
 8         int iter2 = 1;
 9         int f = 0;
10 
11         for (int i = 2; i <= n; i++)
12         {
13           f = iter1 + iter2;
14           iter1 = iter2;
15           iter2 = f;
16         }
17 
18         return f;
19       }
20     }
 
 
 
同样是斐波那契数列，由于实际只有前两个计算结果有用，我们可以使用中间变量来存储，这样就不用创建数组以节省空间。同样算法复杂度优化为 O(n)。
 
示例代码（10）：
 
通过使用矩阵乘方的算法来优化斐波那契数列算法。
 
 
 
 1     static int Fibonacci(int n)
 2     {
 3       if (n <= 1)
 4         return n;
 5 
 6       int[,] f = { { 1, 1 }, { 1, 0 } };
 7       Power(f, n - 1);
 8 
 9       return f[0, 0];
10     }
11 
12     static void Power(int[,] f, int n)
13     {
14       if (n <= 1)
15         return;
16 
17       int[,] m = { { 1, 1 }, { 1, 0 } };
18 
19       Power(f, n / 2);
20       Multiply(f, f);
21 
22       if (n % 2 != 0)
23         Multiply(f, m);
24     }
25 
26     static void Multiply(int[,] f, int[,] m)
27     {
28       int x = f[0, 0] * m[0, 0] + f[0, 1] * m[1, 0];
29       int y = f[0, 0] * m[0, 1] + f[0, 1] * m[1, 1];
30       int z = f[1, 0] * m[0, 0] + f[1, 1] * m[1, 0];
31       int w = f[1, 0] * m[0, 1] + f[1, 1] * m[1, 1];
32 
33       f[0, 0] = x;
34       f[0, 1] = y;
35       f[1, 0] = z;
36       f[1, 1] = w;
37     }
 
 
 
优化之后算法复杂度为O(log2n)。
 
示例代码（11）：
 
在 C# 中更简洁的代码如下。
 
 
 
1     static double Fibonacci(int n)
2     {
3       double sqrt5 = Math.Sqrt(5);
4       double phi = (1 + sqrt5) / 2.0;
5       double fn = (Math.Pow(phi, n) - Math.Pow(1 - phi, n)) / sqrt5;
6       return fn;
7     }
 
 
 
示例代码（12）：
 
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的有序数据。算法适用于少量数据的排序，时间复杂度为 O(n2)。
 
 
 
 1     private static void InsertionSortInPlace(int[] unsorted)
 2     {
 3       for (int i = 1; i < unsorted.Length; i++)
 4       {
 5         if (unsorted[i - 1] > unsorted[i])
 6         {
 7           int key = unsorted[i];
 8           int j = i;
 9           while (j > 0 && unsorted[j - 1] > key)
10           {
11             unsorted[j] = unsorted[j - 1];
12             j--;
13           }
14           unsorted[j] = key;
15         }
16       }
17     }
 
 
在描述算法复杂度时,经常用到o(1), o(n), o(logn), o(nlogn)来表示对应算法的时间复杂度, 这里进行归纳一下它们代表的含义:
 
这是算法的时空复杂度的表示。不仅仅用于表示时间复杂度，也用于表示空间复杂度。
 O后面的括号中有一个函数，指明某个算法的耗时/耗空间与数据增长量之间的关系。其中的n代表输入数据的量。
 
O(1)就是最低的时空复杂度了，也就是耗时/耗空间与输入数据大小无关，无论输入数据增大多少倍，耗时/耗空间都不变。 哈希算法就是典型的O(1)时间复杂度，无论数据规模多大，都可以在一次计算后找到目标（不考虑冲突的话）
 

 比如时间复杂度为O(n)，就代表数据量增大几倍，耗时也增大几倍。比如常见的遍历算法
 

 比如时间复杂度O(n^2)，就代表数据量增大n倍时，耗时增大n的平方倍，这是比线性更高的时间复杂度。比如冒泡排序，就是典型的O(n^2)的算法，对n个数排序，需要扫描n×n次。
 

 比如O(logn)，当数据增大n倍时，耗时增大logn倍（这里的log是以2为底的，比如，当数据增大256倍时，耗时只增大8倍，是比线性还要低的时间复杂度）。二分查找就是O(logn)的算法，每找一次排除一半的可能，256个数据中查找只要找8次就可以找到目标。
 

 O(nlogn)同理，就是n乘以logn，当数据增大256倍时，耗时增大256*8=2048倍。这个复杂度高于线性低于平方。归并排序就是O(nlogn)的时间复杂度。
 
通过表格对比 
 

 下面的图更容易看懂 
 
 
 
 
 
 
 
 
 
 
 
 
--------------------- 
 

 作者：T9的第三个三角 
 来源：CSDN 
 原文：https://blog.csdn.net/dazhaoDai/article/details/81631195 
 版权声明：本文为博主原创文章，转载请附上博文链接！
 
 
 
 
 
zzzhouheng
 
时间复杂度On和空间复杂度O1是什么意思？
 
（1）、把输入规模看成x轴，所花时间/空间看成y轴
 
O（n）就是y=x，y随x的增长而线性增长。也就是成正比，一条斜线。
 
O（1）就是y=1，是一个常量，不管x怎么变，y不变，一条与x轴平行的线。
 
（2）、举个简单的例子，要从0加到n，我们会这么写：
 
 
1
 
2
 
3
 
4
 
 
int sum = 0;
 
for(int i = 0;i<=n;++i) {
 
    sum + = i; 
 
}
 
一共算了n次加法，那么就说这个时间复杂度是O（n）。当然O（n）的精确的概念是，是n的最高次方，比如，某个计算共计算了3n+2次，那么这个时间复杂度也是O（n），因为3n+2中的最高次方是n。
 
如果代码这么写：
 
 
1
 
2
 
3
 
4
 
5
 
6
 
 
int sum = 0;
 
for(int i = 0;i<= n;i++) {
 
        for(int j = 0;j<= n;j++) {
 
               sum + = (i + j);        
 
          }
 
}
 
　　
 
很明显一共算了n^2次加法，那么就说这个时间复杂度是O（n^2），和这个上面的类似，如果某个算法计算了3*n^2+n+1次，其时间复杂度仍然是O（n^2），因为3*n^2+n+1中的最高的次方是n^2，所谓O1就是计算的次数是常量，我们还以上面从0到n的例子来说，如果我们用等差数列的公式，那么，代码可以这么写：
 
int sum = n*(n+1)/2
 
不管n有多大（当然不能溢出了），通过上面的公式只需要计算一次，也就是说计算的次数是不变的，这种情况的时间复杂度就可以说成O（1），再比如这个计算，不管其他条件如何变化，均只计算5次就能计算出结果，那么这种情况就是时间复杂度，也就是O（1）。
 
（3）、
 
要在hash表中找到一个元素就是O（1）
 
要在无序数组中找到一个元素就是O（n）
 
访问数组的第n个元素是O（1）
 
访问链表的第n个元素是O（n）
 
也就是说：
 
如果实现中没有循环就是O（1）
 
 如果实现中有一个循环就是O（n）
 
（4）、算法复杂度：算法复杂度分为时间时间复杂度和空间复杂度。其作用是：时间复杂度是度量算法执行时间的长短；而空间复杂度是指算法所需存储空间的大小。

 
 
在你渐渐迷失在你的人生道路上的时候，千万不要因为走的太久，而忘记了我们为什么出发，做码农，也要清楚自己如何才能用有效的土地种植出 出色的产品，于是细节就需要把握一下。
 
 
如果你有兴趣可以关注一下公众号 biglead 我的大前端生涯，获取每日学习资料
 
 
在描述算法复杂度时，经常用到O(1), O(n), O(logn), O(nlogn)来表示对应复杂度程度，可以用于表示时间复杂度，也用于表示空间复杂度。
 
类别
描述
O(1)
耗时与输入数据量大小无关
O(n)
数据量增大几倍，耗时也增大几位
O(n^2)
对 n 个数进行排序，需要扫描 n X n 次
O(logn)
当数据量增大 n 倍时 ，扫描次数增大 logn 次（以2为底数）
O(nlogn)

时间复杂度的推导遵循3个原则：
 
如果运行时间跟n无关，是常数，则时间复杂度是O(1)；
只保留时间函数中的最高阶项；
去掉高阶项前面的系数；
 
 
1 O(1)
 
若运行时间跟n的取值无关，即无论n取什么值，我的运行时间都不会变，则时间复杂度为O(1)，只要基本操作执行次数是个常量，时间复杂度都为O(1)。
 
2 O(n)出现情况
 
O(n)一般出现在只有一个循环的情况下，执行次数是线性的，如下：
 
public void test(int number) {
	for(int i = 0 ; i < number ; i++) {
		... 其他代码
	}
}
 
3 O(n^2)出现情况
 
O(n^2)一般出现在有嵌套循环的情况下
 
public void test(int n) {
    int a = 1;
    int b = 1;
	for(int i = 0 ; i < n ; i++) {
		for(int j = 0 ; j < n ; j++) {
			a++;
		}
		b++;
	}
}

 
上术循环中执行次数是 n x n 次 ,时间复制度为O(n^2)

1.名词解析
 
O(x):表示算法时空（时间/空间）的复杂度
 
O括号里的函数 x 表示：某个算法的耗时/耗空间与数据增长量之间的关系。其中O(n),O(n^2)等的 n 表示输入数据的量
 
2.O(1)
 
O(1)，即是最低的时空复杂度。即，耗时/耗空间与输入数据大小无关，无论输入数据增大多少倍，耗时/耗空间都不变
 例：哈希算法，无论数据规模多大，都可以在一次计算后找到目标（不考虑冲突的话）
 
3.O(n)
 
时间复杂度为O(n)，就代表数据量增大几倍，耗时也增大几倍
 例：遍历算法，找数组里最大或最小的值，需要把数组的 n 元素遍历一次，操作 n 次
 
4.O(n^2)
 
时间复杂度O(n^2)，就代表数据量增大n倍时，耗时增大n的平方倍
 例：冒泡排序，双重for循坏，对n个数排序，需要扫描n×n次
 
5.O(log n)
 
当数据增大n倍时，耗时增大log n倍（这里的log是以2为底的，比如，当数据增大256倍时，耗时只增大8倍）
 例：二分查找，每找一次排除一半的可能，256个数据中查找只要找8次就可以找到目标
 
6.O(n log n)
 
O(n log n)同理，就是n乘以log n，当数据增大256倍时，耗时增大256*8=2048倍
 例：归并排序

时间复杂度
 算法分析
 
同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。一个算法的评价主要从时间复杂度和空间复杂度来考虑。
 
一、时间复杂度
 
（1）时间频度
 
一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
 
（2）时间复杂度
 
在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。
 
一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
 
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。
 
按数量级递增排列，常见的时间复杂度有：
 
常数阶O(1),对数阶O(log2n),线性阶O(n),
 
线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),…，
 
k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。
 
2、空间复杂度
 
与时间复杂度类似，空间复杂度是指算法在计算机内执行时所需存储空间的度量。记作:
 
S(n)=O(f(n))
 
我们一般所讨论的是除正常占用内存开销外的辅助存储单元规模
 
二、常见算法时间复杂度：
 
O(1): 表示算法的运行时间为常量
 
O(n): 表示该算法是线性算法
 
O(㏒2n): 二分查找算法
 
O(n2): 对数组进行排序的各种简单算法，例如直接插入排序的算法。
 
O(n3): 做两个n阶矩阵的乘法运算
 
O(2n): 求具有n个元素集合的所有子集的算法
 
O(n!): 求具有N个元素的全排列的算法
 
优<---------------------------<劣
 
O(1)<O(㏒2n)<O(n)<O(n2)<O(2n)
 
时间复杂度按数量级递增排列依次为：常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(nlog2n)、平方阶O(n2)、立方阶O(n3)、……k次方阶O(nk)、指数阶O(2n)。
 
三、算法的时间复杂度（计算实例）
 
定义：如果一个问题的规模是n，解这一问题的某一算法所需要的时间为T(n)，它是n的某一函数 T(n)称为这一算法的“时间复杂性”。
 
当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。
 
我们常用大O表示法表示时间复杂性，注意它是某一个算法的时间复杂性。大O表示只是说有上界，由定义如果f(n)=O(n)，那显然成立f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时候一般都习惯表示前者。
 
此外，一个问题本身也有它的复杂性，如果某个算法的复杂性到达了这个问题复杂性的下界，那就称这样的算法是最佳算法。
 
“大O记法”：在这种描述中使用的基本参数是 n，即问题实例的规模，把复杂性或运行时间表达为n的函数。这里的“O”表示量级 (order)，比如说“二分检索是 O(logn)的”,也就是说它需要“通过logn量级的步骤去检索一个规模为n的数组”记法 O ( f(n) )表示当 n增大时，运行时间至多将以正比于 f(n)的速度增长。
 
这种渐进估计对算法的理论分析和大致比较是非常有价值的，但在实践中细节也可能造成差异。例如，一个低附加代价的O(n2)算法在n较小的情况下可能比一个高附加代价的 O(nlogn)算法运行得更快。当然，随着n足够大以后，具有较慢上升函数的算法必然工作得更快。
 
O(1)
 
Temp=i;i=j;j=temp;
 
以上三条单个语句的频度均为1，该程序段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶，记作T(n)=O(1)。如果算法的执行时 间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。
 
O(n^2)
 
2.1. 交换i和j的内容
 
 sum=0；                 （一次）

 for(i=1;i<=n;i++)       （n次 ）

    for(j=1;j<=n;j++) （n^2次 ）

     sum++；       （n^2次 ）
 
解：T(n)=2n^2+n+1 =O(n^2)
 
2.2.
 
for (i=1;i<n;i++)

{

    y=y+1;         ①   

    for (j=0;j<=(2*n);j++)    

       x++;        ②      

}         
 
解： 语句1的频度是n-1
 
      语句2的频度是(n-1)*(2n+1)=2n^2-n-1

      f(n)=2n^2-n-1+(n-1)=2n^2-2

      该程序的时间复杂度T(n)=O(n^2).         
 
O(n)
 
2.3.
 
a=0;

b=1;                      ①

for (i=1;i<=n;i++) ②

{  

   s=a+b;　　　　③

   b=a;　　　　　④  

   a=s;　　　　　⑤

}
 
解： 语句1的频度：2,
 
       语句2的频度： n,        

      语句3的频度： n-1,        

      语句4的频度：n-1,    

      语句5的频度：n-1,                                  

      T(n)=2+n+3(n-1)=4n-1=O(n).
 
O(log2n )
 
2.4.
 
 i=1;       ①

while (i<=n)

   i=i*2; ②
 
解： 语句1的频度是1,
 
      设语句2的频度是f(n),   则：2^f(n)<=n;f(n)<=log2n    

      取最大值f(n)= log2n,

      T(n)=O(log2n )
 
O(n^3)
 
2.5.
 
for(i=0;i<n;i++)

{  

   for(j=0;j<i;j++)  

   {

      for(k=0;k<j;k++)

         x=x+2;  

   }

}
 
解：当i=m, j=k的时候,内层循环的次数为k当i=m时, j 可以取 0,1,…,m-1 , 所以这里最内循环共进行了0+1+…+m-1=(m-1)m/2次所以,i从0取到n, 则循环共进行了: 0+(1-1)*1/2+…+(n-1)n/2=n(n+1)(n-1)/6所以时间复杂度为O(n^3).
 
我们还应该区分算法的最坏情况的行为和期望行为。如快速排序的最 坏情况运行时间是 O(n^2)，但期望时间是 O(nlogn)。通过每次都仔细 地选择基准值，我们有可能把平方情况 (即O(n^2)情况)的概率减小到几乎等于 0。在实际中，精心实现的快速排序一般都能以 (O(nlogn)时间运行。
 
下面是一些常用的记法：
 
访问数组中的元素是常数时间操作，或说O(1)操作。一个算法如 果能在每个步骤去掉一半数据元素，如二分检索，通常它就取 O(logn)时间。用strcmp比较两个具有n个字符的串需要O(n)时间 。常规的矩阵乘算法是O(n^3)，因为算出每个元素都需要将n对 元素相乘并加到一起，所有元素的个数是n^2。
 
指数时间算法通常来源于需要求出所有可能结果。例如，n个元 素的集合共有2n个子集,所以要求出所有子集的算法将是O(2n)的 。指数算法一般说来是太复杂了，除非n的值非常小，因为，在 这个问题中增加一个元素就导致运行时间加倍。不幸的是，确实有许多问题 (如著名 的“巡回售货员问题” )，到目前为止找到的算法都是指数的。如果我们真的遇到这种情况， 通常应该用寻找近似最佳结果的算法替代之。