【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题-1

简介: 【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题

一、什么是时间复杂度和空间复杂度

1.1 算法效率

算法效率分析分为两种:第一种是时间效率,第二种是空间效率。时间效率被称为时间复杂度,而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度,而空间复杂度主要衡量一个算法所需要的额外空间,在计算机发展的早期,计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展,计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。


1.2 时间复杂度的概念

时间复杂度的定义:在计算机科学中,算法的时间复杂度是一个函数,它定量描述了该算法的运行时间。一个算法执行所耗费的时间,从理论上说,是不能算出来的,只有在电脑上跑起来之后才知道,而且根据电脑硬件配置的不同,同一个程序跑的效率可能是不一样的,所以时间复杂度不是计算一个程序跑的时间长短。而是一个算法所花费的时间与其中语句的执行次数成正比例,算法中的基本操作的执行次数,为算法的时间复杂度,时间复杂度通常用大O渐进表示法。


1.3 空间复杂度的概念

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes的空间,因为这个也没太大意义,所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似,也使用大O渐进表示法。


1.4 复杂度计算在算法中的意义

一张图告诉你复杂度计算的意义:

cae31dd6adeb6fc0f2ce1effe5a78160_2e4c10a285fe4b3eb40d0c46cbae9f0b.png

二、时间复杂度的计算

2.1 大O渐进表示法
// 请计算一下Func1基本操作执行了多少次?
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);
}

0f92fe4adcae10efcc7083172aa70c64_7d095ad4eb174da5939b84e0181b0c51.png

Func1 执行的操作次数 :

F(N)=N2+2N+10


当N = 10, F(N)= 130

当N = 100,F(N)= 10210

当N = 1000,F(N)= 1002010


我们会发现,随着N的增大,这个表达式中N^2对结果的影响是最大的。时间复杂度其实是一个估算,是去看表达式中影响最大的那一项,后面的可以直接忽略掉,类似于数学中的极限。时间复杂度我们用大O的渐进表示法。


大O符号(Big O notation):是用于描述函数渐进行为的数学符号。

推导大O阶方法:


1、用常数1取代运行时间中的所有加法常数。

2、在修改后的运行次数函数中,只保留最高阶项。

3、如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。


使用大O的渐进表示法以后,Func1的时间复杂度为:

O(N2


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

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


最坏情况:任意输入规模的最大运行次数(上界)

平均情况:任意输入规模的期望运行次数

最好情况:任意输入规模的最小运行次数(下界)


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


最好情况:1次找到

最坏情况:N次找到

平均情况:N/2次找到


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


2.2 常见时间复杂度计算举例【示例1】:

// 计算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);
}

7dbb299839e63012572fc0ef10d79d05_2c328d3093604e9c8c3c0ee6408dca13.png

Func2的执行操作次数:F(N)=2N+10


根据上面的大O渐进表示法,最高阶的系数不为1,就去除最高项的系数,即Func2的时间复杂度为:O(N)


【示例2】:

// 计算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);
}

116201266c09b243381dd2a9c2a3b7b9_6eb16386257f493eb07958326c9052ac.png

Func3的执行操作次数:

F(N)=N+M


时间复杂度为:

O(M+N)


由于不确定M和N的大小,所以这里都不能忽略掉。假设给了条件:

M远大于N,那么其时间复杂度就是O(M)

M和N差不多大,那么其时间复杂度就是O(M)或则O(N),相当于两倍的M或则N。

【示例3】:

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

像这种可以直接知道具体的执行次数的那么那么他的时间复杂度就是:


O(1)


注意:如果一个算法的时间复杂度为O(1)并不是他执行一次,而是执行了常数次,这个常数不一定是1,可能是10,可能是100,也有可能是1000,反正是一个具体的数。

【示例4】:

// 计算strchr的时间复杂度?
const char * strchr ( const char * str, char character )
{
    while(*str != '\0')
    {
        if(*str == character)
            return str;
        ++str;
    }
    return NULL;
}

ce4f7c53c4adfbbaa1315cc210c7dc0c_18751c3a66eb49c1a1c5b405728ece9f.png

对于这个算法要分情况(假设字符串长度为N):


最好情况:只执行一次就找到了所需字符,时间复杂度为O(1)

平均情况:执行到N/2的时候找到所需字符,时间复杂度为O(N / 2)

最坏情况:执行到N次才找到所需字符,时间复杂度为O(N)


像这种需要分情况的算法,我们一般都会采取最坏的打算,毕竟具体的执行次数是不确定的,取最坏情况也就意味着不会出现更差的情况,更加合理。

所以这个算法的时间复杂度就是:O(N)

【示例5】:

// 计算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;
    }
}

冒泡排序的时间复杂度的计算,假设数组的长度为N:

比较次数:

第一趟冒泡:N

第二趟冒泡:N - 1

第三趟冒泡:N - 2

第N趟冒泡:1

具体的执行次数:

F(N)=(N+1)∗N/2


展开之后得到的时间复杂度就是:

O(N2


【示例6】:

// 计算BinarySearch的时间复杂度?
int BinarySearch(int* a, int n, int x)
{
    assert(a);
    int begin = 0;
    int end = n;
    while (begin < end)
    {
        int mid = begin + ((end-begin)>>1);
        if (a[mid] < x)
            begin = mid+1;
        else if (a[mid] > x)
            end = mid;
        else
            return mid;
    }
    return -1;
}

二分查找的时间复杂度计算,假设数组长度为N:

使用二分查找首先要确保这个数组是有序的,选定一个中间值,如果所找的值比中间值要大,就可以利用left来缩放空间(mid的取值范围在left和right之间,一般取left和right的中间值),每次查找都能折半,直到找到所需的值。

这种算法也需要分情况:

我们假设找了X次,数组长度为N:


最好情况(X = 1):只找了一次,时间复杂度为O(1)

找的次数:1 * 2 * 2 * 2 … * 2 = N --> 2^X = N

最坏情况:找的次数为

X=log2N

在算法的复杂度计算中,习惯省略对数的底数,即这个算法的时间复杂度为:

O(N)=logN


【示例7】:

// 计算阶乘递归Factorial的时间复杂度?
long long Factorial(size_t N)
{
    return N < 2 ? N : Factorial(N-1)*N;
}

求10的阶乘:

递归调用了N次,每次递归运算了 --> O(1)

即这个算法的时间复杂度为:

O(N)

常见的复杂度对比:


【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题-2

https://developer.aliyun.com/article/1538358

相关文章
|
24天前
|
存储 算法 C语言
【数据结构与算法 刷题系列】合并两个有序链表
【数据结构与算法 刷题系列】合并两个有序链表
|
17天前
|
存储 算法 搜索推荐
|
24天前
|
算法 数据中心 C++
基于C++雪花算法工具类Snowflake -来自chatGPT
基于C++雪花算法工具类Snowflake -来自chatGPT
17 1
|
1月前
|
算法 前端开发 Linux
【常用技巧】C++ STL容器操作:6种常用场景算法
STL在Linux C++中使用的非常普遍,掌握并合适的使用各种容器至关重要!
44 10
|
29天前
|
算法 数据处理 C++
C++一分钟之-迭代器与算法
【6月更文挑战第21天】C++ STL的迭代器统一了容器元素访问,分为多种类型,如输入、输出、前向、双向和随机访问。迭代器使用时需留意失效和类型匹配。STL算法如查找、排序、复制要求特定类型的迭代器,注意容器兼容性和返回值处理。适配器和算法组合增强灵活性,但过度使用可能降低代码可读性。掌握迭代器和算法能提升编程效率和代码质量。
28 3
|
1月前
|
算法 C++
【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题-2
【数据结构与算法】:关于时间复杂度与空间复杂度的计算(C/C++篇)——含Leetcode刷题
|
1月前
|
存储 算法 C++
【数据结构与算法】:带你手搓顺序表(C/C++篇)
【数据结构与算法】:带你手搓顺序表(C/C++篇)
|
24天前
|
算法 搜索推荐 C++
C++之STL常用算法(遍历、查找、排序、拷贝、替换、算数生成、集合)
C++之STL常用算法(遍历、查找、排序、拷贝、替换、算数生成、集合)
18 0
|
24天前
|
算法
【数据结构与算法 刷题系列】求带环链表的入环节点(图文详解)
【数据结构与算法 刷题系列】求带环链表的入环节点(图文详解)
|
24天前
|
算法
【数据结构与算法 刷题系列】判断链表是否有环(图文详解)
【数据结构与算法 刷题系列】判断链表是否有环(图文详解)