【一次性带你学会时间复杂度】

时间复杂度

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

例如：

// 请计算一下Func1中++count语句总共执行了多少次？
void Func1(int N)
{
    int count = 0;
    for (int i = 0; i < N ; ++ i)
    {
        for (int j = 0; j < N ; ++ j)
        {
            ++count;
        }
    }
 
    for (int k = 0; k < 2 * N ; ++ k)
    {
         ++count;
    }
    int M = 10;
    while (M--)
    {
         ++count;
    }
    printf("%d\n", count);
}

第一个for循环执行N次，每次循环里面再循环N次，所以，++count这条语句被执行了N^2次；

第二个for循环执行了2*N次；

while循环执行了10次；

所以，Func1执行的操作次数：F(N) = N^2 + 2*N + 10

• N = 10        F(N) = 130
• N = 100      F(N) = 10210
• N = 1000    F(N) = 1002010

实际上我们计算时间复杂度时，并不一定要计算精确的执行次数，而只需要计算大概执行次数，那么这里我们使用大O的渐进表示法。

大O的渐进表示法：

大O符号：是用于描述函数渐进行为的数学符号

推导大O阶方法：

1. 用常数1取代运行时间中的所有加法常数
2. 在修改后的运行次数函数中，只保留最高阶项
3. 如果最高阶项存在且不是1，则除去与这个项目相乘的常数。得到的结果就是大O阶。

使用大O渐进法表示以后，上述Func1的时间复杂度为：O(N^2)

• N = 10        F(N) = 100
• N = 100      F(N) = 10000
• N = 1000    F(N) = 1000000

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行

次数。

另外有些算法的时间复杂度存在最好、平均和最坏情况： ​​​​​​​

• 最好情况：任意输入规模的最小运行次数(下界)
• 平均情况：任意输入规模的期望运行次数
• 最坏情况：任意输入规模的最大运行次数(上界)

例如：在一个长度为N数组中搜索一个数据x

1. 最好情况：1次找到
2. 最坏情况：N次找到
3. 平均情况：N/2次找到

在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

来几个题练习一下：

例一：

// 计算Func2的时间复杂度？
void Func2(int N)
{
    int count = 0;
    for (int k = 0; k < 2 * N ; ++ k)
    {
        ++count;
    }
    int M = 10;
    while (M--)
    {
        ++count;
    }
    printf("%d\n", count);
}

执行次数：F(N) = 2*N + 10;        时间复杂度：O(N)

例二：

// 计算Func3的时间复杂度？
void Func3(int N, int M)
{
    int count = 0;
    for (int k = 0; k < M; ++ k)
    {
        ++count;
    }
    for (int k = 0; k < N ; ++ k)
    {
        ++count;
    }
    printf("%d\n", count);
}

执行次数：F(N) = M + N;        时间复杂度：O(M+N)

例三：

// 计算Func4的时间复杂度？
void Func4(int N)
{
    int count = 0;
    for (int k = 0; k < 100; ++ k)
    {
        ++count;
    }
    printf("%d\n", count);
}

执行次数：F(N) = 100        时间复杂度：O(1)

例四：

// 计算strchr的时间复杂度？
const char * strchr ( const char * str, int character )
{
    while(*str)
    {
        if(*str == character)
        {
            return str;
        }
        str++;
    }
    return NULL;
}

执行次数：最坏情况下是字符串的最后一个字符，要执行字符串的长度次，N次

时间复杂度：O(N)

例五：

// 计算BubbleSort的时间复杂度？
void BubbleSort(int* a, int n)
{
    assert(a);
    for (size_t end = n; end > 0; --end)
    {
        int exchange = 0;
        for (size_t i = 1; i < end; ++i)
        {
            if (a[i-1] > a[i])
            {
                Swap(&a[i-1], &a[i]);
                exchange = 1;
            }
        }
        if (exchange == 0)
            break;
    }
}

第一次循环：end = n        第二层for循环执行n-1次

第二次循环：end = n-1     第二层for循环执行n-2次

……

第n次循环：当end = 1      第二层循环执行0次

很明显这是一个等差数列：F(N) = n * (n - 1) / 2

时间复杂度：O(N^2)

例六：

// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x)
{
    assert(a);
    int begin = 0;
    int end = n-1;
    // [begin, end]：begin和end是左闭右闭区间，因此有=号
    while (begin <= end)
    {
        int mid = begin + ((end-begin)>>1);
        if (a[mid] < x)
            begin = mid+1;
        else if (a[mid] > x)
            end = mid-1;
        else
            return mid;
    }
    return -1;
}

二分查找每次就会排除一半的数据，最后一次只剩一个数了就可以得出结果了（找到或没找到），

假设共找了x次，一共有n个数据，所以2^x = n;得到x = log₂N

时间复杂度：O(log₂N)

例七：

// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
    if(0 == N)
        return 1;
    return Fac(N-1)*N;
}

递归N次

执行次数：F(N) = N+1

时间复杂度：O(N)​​​​​​​