一. 算法复杂度

算法 (Algorithm)，是对特定问题求解步骤的一种描述。解决一个问题往往有不止一种方法，算法也是如此。那么解决特定问题的多个算法之间如何衡量它们的优劣呢？好的程序设计无外乎两点，"快"和"省"。"快"指程序执行速度快，高效，"省"指占用更小的内存空间。这两点其实就对应"时间复杂度"和"空间复杂度"的问题。

那么怎样分析一个程序的时间复杂度和空间复杂度？"大O表示法"表示程序的执行时间或占用空间随数据规模的增长趋势。被用来描述一个算法的性能或复杂度。大O表示法可以用来描述一个算法的最差情况，或者一个算法执行的耗时或占用空间（例如内存或磁盘占用）。

大O表示法表示时间复杂度，注意它是某一个算法的时间复杂度。大O表示只是说有上界，由定义如果 f(n)=O(n)，那显然成立 f(n)=O(n^2)，它给你一个上界，但并不是上确界，但人们在表示的时候一般都习惯表示前者。此外，一个问题本身也有它的复杂度，如果某个算法的复杂度到达了这个问题复杂度的下界，那就称这样的算法是最佳算法。

同一个问题可以用不同的算法解决，而一个算法的优劣将影响到算法乃至程序的效率。算法分析的目的在于为特定的问题选择合适算法。一个算法的评价主要从时间复杂度和空间复杂度来考虑。但是算法在时间的高效性和空间的高效性之间通常是矛盾的。所以一般只会取一个平衡点。通常我们假设程序运行在足够大的内存空间中，所以研究更多的是算法的时间复杂度。

1. 时间复杂度

一个算法执行所花费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。而且一个算法花费的时间与算法中的基本操作语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度，记为T(n)。

在时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。为了知道变化时呈现什么规律，所以引入时间复杂度。一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。记为O(…)，也称为大O表示法；

T(n) = O(f(n))

算法的时间复杂度是指算法需要消耗的时间资源。

2. 空间复杂度

算法的空间复杂度是指算法需要消耗的空间资源。
其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。

二. 什么是大O表示法？

1. Big O 表示法的概念
在实际上，精确计算公式是不可能被统计计算出来的，因为不同的语句，不同的操作，耗费的时间也是不一样。所以，在实际应用中，我们不需要精确计算，只需要一个公式，来表达时间花费和数据集大小的渐近关系。所以，在描述算法的时候，一般采用大O(Big-O notation)表示，又称为渐进符号，时间复杂度，又称"渐进式时间复杂度"，表示代码执行时间与数据规模之间的增长关系。

2. Big O 表示法的特点
大O符号是关于一个算法的最坏情况的。例如:你要从一个大小为 100 的数字数组中找出一个数值等于 10 的元素，我们可以从写一个循环，从头到尾对数据进行扫描，这个复杂度就是 O(n)，这里 n 等于 100，实际上有可能第 1 次就找到了，也有可能是第 100 次才找到，但是大 O 表示法考虑的是最坏的情况，也就是一个算法理论上要执行多久才能覆盖所有的情况。

3.Big O 表示法怎么看？怎么用？
假设一个算法的时间复杂度是 O(n)，n 在这里代表的意思就是数据的个数。举个例子，如果你的代码用一个循环遍历 100 个元素，那么这个算法就是 O(n)，n 为 100，所以这里的算法在执行时就要做 100 次工作。

4.Big O 常见的时间复杂度有：
常数阶O(1)，对数阶O(log2n)，线性阶O(n)，线性对数阶O(nlog2n)，平方阶O(n2)，立方阶O(n3)，...， k次方阶O(nk)，指数阶O(2n)。

随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

三. 常见的大O表示法

1.O(1) 常数级

不论输入数据量有多大，这个算法的运行时间总是一样的。该算法的执行时间（或执行时占用空间）总是为一个常量，不论输入的数据集是大是小。也就是说代码片段执行时间不随数据规模n的增加而增加，即使执行次数非常大，只要与数据规模无关，都算作常量阶。
例如：

boolean isFirstElementEmpty(List elements){
  return elements.get(0).isEmpty();
}

应用:

基于索引取出数组中对应的元素。
哈希算法就是典型的 O ( 1 ）时间复杂度，无论数据规模多大，都可以在一次计算后找到目标（不考虑冲突的话）

速度：
最快的

2. O(log n) 对数级

这种算法每次循环时会把需要处理的数据量减半。如果你有 100 个元素，则只需要七步就可以找到答案。1000 个元素只要十步。100,0000 元素只要二十步。即便数据量很大这种算法也非常快。
例如：

public int binarySearch(int[] arr, int value) {
  int start = 0, end = arr.length - 1;
  while (start <= end) {
    int middle = (start + end) / 2;
    if (value == arr[middle]) {
      return middle;
    }
    if (value > arr[middle]) {
      start = middle + 1;
    }
    if (value < arr[middle]) {
      end = middle - 1;
    }
  }
  return -1;
}

应用：
二分查找就是 O ( logn ）的算法，每找一次排除一半的可能， 256 个数据中查找只要找 8 次就可以找到目标。

速度：
相当好

3. O(n) 线性级

O(n),算法的执行时间呈线性关系。如果你有 100 个元素，这种算法就要做 100 次工作。数据量翻倍那么运行时间也翻倍。

public boolean ContainsValue(List elements, String value) {
  int n = elements.size();
  for (int i = 0; i < n; i++) {
    if (elements.get(i).equals(value)) {
        return true;
     }
  }
  return false;
}

时间花费cost和输入的array有关，呈线性关系。寻找item要把array遍历一次。
例如:
遍历查找

速度：
还不错

4. O(n^2) 二次方级

O(n^2 ), 有点慢。如果你有 100 个元素，这种算法需要做 100^2 = 10000 次工作。数据量 x 2 会导致运行时间 x 4 (因为 2 的 2 次方等于 4)。例子：循环套循环的算法，比如插入排序。
O(n2)表示算法的复杂度与数据集大小的平方成正比，一般的循环嵌套就是这种，随着嵌套的层级增加可能是O(n3)、O(n4)等。

boolean ContainsDuplicates(List elements) {
  for (int i = 0; i < elements.size(); i++) {
    for (int j = 0; j < elements.size(); j++) {
      if (i == j) continue;
      if (elements.get(i).equals(elements.get(j))) return true;
    }
  }
  return false;
}

应用：
选择排序

速度：
有点慢。

5. O(2^n)指数级

表示算法的复杂度与数据集大小成指数增长。

应用：
递归

速度：
速度：特别慢。

四. 总结

Big-O	名字	描述
O(1)	常数级	最好的。不论输入数据量有多大，这个算法的运行时间总是一样的。例子: 基于索引取出数组中对应的元素。
O(log n)	对数级	相当好。这种算法每次循环时会把需要处理的数据量减半。如果你有 100 个元素，则只需要七步就可以找到答案。1000 个元素只要十步。100,0000 元素只要二十步。即便数据量很大这种算法也非常快。例子：二分查找。
O(n)	线性级	还不错。如果你有 100 个元素，这种算法就要做 100 次工作。数据量翻倍那么运行时间也翻倍。例子：线性查找。
O(n log n)	线性对数级	还可以。比线性级差了一些，不过也没那么差劲。例子：最快的通用排序算法。
O(n^2)	二次方级	有点慢。如果你有 100 个元素，这种算法需要做 100^2 = 10000 次工作。数据量 x 2 会导致运行时间 x 4 (因为 2 的 2 次方等于 4)。例子：循环套循环的算法，比如插入排序。
O(n^3)	三次方级	特别慢。如果你有 100 个元素，那么这种算法就要做 100^3 = 100,0000 次工作。数据量 x 2 会导致运行时间 x 8。例子：矩阵乘法。
O(2^n)	指数级	超级慢。这种算法你要想方设法避免，但有时候你就是没得选。加一点点数据就会把运行时间成倍的加长。例子：旅行商问题。
O(n!)	阶乘级	比蜗牛还慢！不管干什么都要跑个 N 年才能得到结果。

说明：

大部分情况下用直觉就可以知道一个算法的大 O 表示法。比如说，如果你的代码用一个循环遍历你输入的每个元素，那么这个算法就是 O(n)。如果是循环套循环，那就是 O(n^2)。如果 3 个循环套在一起就是 O(n^3)，以此类推。
大 O 表示法只是一种估算，仅仅在比较两种算法哪种更好的时候才有点用。当数据量大的时候才有用。但归根结底，还是要实际测试之后才能得出结论。而且如果数据量相对较小，哪怕算法比较慢，在实际使用也不会造成太大的问题。举个例子，插入排序(Insertion Sort)的最糟情况运行时间是 O(n^2)。理论上来说它的运行时间比归并排序(Merge Sort)要慢一些。归并排序是 O(n log n)。但对于小数据量，插入排序实际上更快一些，特别是那些已经有一部分数据是排序好的数组。

编程算法之大O表示法