#include <iostream>

using namespace std;

int main()
{
    int n;
    while(cin>>n) {
        int sum = 0;
        for(int i = 1; i <= n; ++i) { // for 循环
            sum += i;
        }
        cout<<"sum = "<<sum<<endl;
    }
    return 0;
}

下面来看下 O(1) 的时间复杂度：

#include <iostream>

using namespace std;

int main()
{
    int n;
    while(cin>>n) {
        cout<<"sum = "<<(1+n)*n/2<<endl;
    }
    return 0;
}

很明显，第一个例子中需要一个 for 循环来求和，for 循环执行 n 次，所以复杂度为 O(n)，第二个例子只需要计算一次即可，所以复杂度为 O(1)。

下面再来看下计算圆的周长和面积的例子：

#include <iostream>
using namespace std;

#define PI 3.1415
int main()
{
    double r;
    while(cin>>r) {
        double s = PI * r * r;
        double c = 2 * PI * r;
        cout<<"The area of the circle is "<<s<<endl;
        cout<<"The circumference of the circle is "<<c<<endl;
    }
    return 0;
}

上述例子中，每次输入半径 r，然后，计算圆的周长和面积。

例子中都是基本的程序执行操作，语句执行次数没有达到一定规模，可以看做是常数阶的复杂度。

✨3.2 对数阶O(logn)

对数阶，常见的是 O(logn) 的对数阶复杂度，f(n) 和规模 n 的关系为：

2^f(n) = n

f(n) =

下面来看一个例子，二分查找算法代码如下所示：

/*
 * 二分查找
 * A[] : 待查找的数组
 *  n  : 数组长度
 * target : 查找的目标值
*/
int binarySearch(int A[], int n, int target) {
    int lt = 0, rt = n;
    while(lt < rt){
        int mid = lt + (rt - lt)/2;
        if(A[mid] == target) return mid;
        else if(A[mid] > target) rt = mid;
        else lt = mid + 1;
    }
    return -1; // 查找不到
}

二分查找算法每次排除一半的元素，相当于每次在规模 n 的基础上除以 2，所以时间复杂度为 O(logn)。

✨3.3 线性阶 O(n)

线性阶是指随着规模 n 的增长，复杂度也是线性增长，f(n) 和规模 n 的关系为：

f(n) = a* n + b （a 和 b 为常数）

下面来看一个例子，输入 n 个数，计算输入的 n 个数的和，如下所示：

#include <iostream>
using namespace std;

int main() {
    int n;
    while(cin>>n) {
        int sum = 0, num;
        for(int i = 0; i < n; ++i) {
            cin>>num;
            sum += num;
        }
        cout<<"The sum is "<<sum<<endl;
    }
    return 0;
}

上例中，计算时间复杂度主要是看 for 循环，一次 for 循环可以看做一个基本操作，需要执行 n 次 for 循环，所以时间复杂度为 O(n)。

看了上面的例子后，有的小伙伴可能就说了，看见单个 for 循环就是 O(n) 的复杂度！

下面就来看一个反例，如下所示：

int function(int n) {
    int sum = 0;    
    for (int i = 2; i < n; i *= 2) {
        sum += i;
    }
    return sum;
}

上例中，2^f(n) = n，f(n) = log2^n，所以时间复杂度为 O(log2^n)，并不是 O(n)。

✨3.4 平方阶 O(n^2)

平方阶是指时间复杂度是规模 n 的平方，规模 n 和 f(n) 的关系为：

f(n) = n^2

来看一个例子，下面是冒泡排序算法，时间复杂度为O(n^2)。

#include <iostream>
using namespace std;
#define SIZE 1000
int main() {
    int n;
    int a[SIZE];
    while(cin>>n) {
        for(int i = 0; i < n; ++i) {
            cin>>a[i];
        }
        // 冒泡排序
        for(int i = 0; i < n - 1; ++i) {
            for(int j = 0; j < n - i - 1; ++j) {
                if(a[j] > a[j+1]) {
                    swap(a[j], a[j+1]);
                }
            }
        }

        for(int i = 0; i < n; ++i) {
            cout<<a[i]<<" ";
        }
        cout<<endl;
    }
    return 0;
}

在上述代码中，时间复杂度主要在冒泡排序上，所以时间复杂度为 O(n^2)。

✨3.5 指数阶 O(2^n)

指数阶，这里以 O(2^n) 为例进行说明，通常指数阶的算法不常见，因为随着 n 的增大，复杂度呈指数增长，f(n) 和规模 n 的关系为：

f(n) = 2^n

下面来看一个例子，计算斐波那契数列，如下所示：

long fibonacci(int n) {    
    if (n <= 1) {        
        return 1;
    } else {        
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

斐波那契数列的公式为：

F(n) = F(n - 1) + F(n - 2) (n > 2)

时间复杂度经过计算后为 O(2^n)（这里的时间复杂度为上述代码中递归算法的时间复杂度）。

🔶🔶🔶🔶🔶 我是分割线 🔶🔶🔶🔶🔶

🍓四、常见空间复杂度分析

空间复杂度没有时间复杂度那么受到重视，在日常的算法中，可能优先考虑的是时间复杂度，因为一些算法的空间并不受限，在一些嵌入式领域可能空间复杂度更重要一点。

✨4.1 O(1)

实质上，很多算法的空间复杂度为 O(1)，比如：冒泡排序、简单选择排序、插入排序等。

✨4.2 O(n)

还是拿排序来举例，归并排序的空间复杂度为 O(n)。

为什么很多排序算法都是 O(1) ，归并排序确是 O(n) 呢？

先来看下归并排序的代码，如下所示：

/*
 * 归并排序
 * 其中, p[]是一个临时数组，存储排序元素
 */
// 合并
void merge(int a[], int lt, int rt, int p[]){
    int mid = (rt - lt)/2 + lt;
    int i = lt, j = mid + 1;
    int k = 0;
    while(i <= mid && j <= rt){ // 合并
        if(a[i] <= a[j]){
            p[k++] = a[i++];
        }else {
            p[k++] = a[j++];
        }
    }
    while(i <= mid){ // 合并剩余的
        p[k++] = a[i++];
    }
    while(j <= rt){ // 合并剩余的
        p[k++] = a[j++];
    }
    for(i = 0; i < k; ++i){ // 重新赋值回去
        a[lt+i] = p[i];
    }
}

// 划分
void mergeSort(int a[], int lt, int rt, int p[]){
    if(lt < rt){
        int mid = (rt - lt)/2 + lt;
        mergeSort(a, lt, mid, p); // 递归排序 lt ~ mid
        mergeSort(a, mid+1, rt, p); // 递归排序 mid+1 ~ rt
        merge(a, lt, rt, p); // 合并 lt ~ rt
    }
}

在上述的归并排序中，主要的空间复杂度在于 p[] 数组那，p[] 数组长度为 n，用于暂存合并后的元素，所以空间复杂度为 O(n)。