【数据结构与算法】：关于时间复杂度与空间复杂度的计算（C/C++篇）—

文章目录

- - 一、什么是时间复杂度和空间复杂度？
  - - 1.1 算法效率
    - 1.2 时间复杂度的概念
    - 1.3 空间复杂度的概念
    - 1.4 复杂度计算在算法中的意义
  - 二、时间复杂度的计算
  - - 2.1 大O渐进表示法
    - 2.2 常见时间复杂度计算举例
  - 三、空间复杂度的计算
  - 四、Leetcode刷题
  - - 1. 消失的数
    - 2. 旋转数组

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

1.1 算法效率

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

1.2 时间复杂度的概念

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

1.3 空间复杂度的概念

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

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

一张图告诉你复杂度计算的意义：
在这里插入图片描述

二、时间复杂度的计算

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);
}

在这里插入图片描述
Func1 执行的操作次数：
$F（N）= N^2 + 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（N^2）$
通过上面我们会发现大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);
}

在这里插入图片描述
Func2的执行操作次数：
$F （ N ） = 2 N + 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);
}

在这里插入图片描述
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;
}

在这里插入图片描述
对于这个算法要分情况（假设字符串长度为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（N^2）$

【示例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 = \log_2 N$
在算法的复杂度计算中，习惯省略对数的底数，即这个算法的时间复杂度为：
$O （ N ） = l o g N$

【示例7】：

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

在这里插入图片描述
求10的阶乘：

递归调用了N次，每次递归运算了 --> O（1）
即这个算法的时间复杂度为：
$O （ N ）$

常见的复杂度对比：
在这里插入图片描述

三、空间复杂度的计算

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

【示例1】：

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

在这里插入图片描述
记住一个点：时间是累计的，空间是不累计的，空间是可以重复利用的，for循环走了N次，重复利用的是一个空间。
即这个算法的空间复杂度为：
$O （ 1 ）$

【示例2】：

// 计算Fibonacci的空间复杂度？
long long* Fibonacci(size_t n)
{
    if(n==0)
        return NULL;
    long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
    fibArray[0] = 0;
    fibArray[1] = 1;
    for (int i = 2; i <= n ; ++i)
    {
        fibArray[i ] = fibArray[ i - 1] + fibArray [i - 2];
    }
    return fibArray ;
}

在这里插入图片描述
空间复杂度为：
$O （ N ）$

【示例3】：

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

在这里插入图片描述

在这里插入图片描述
每次调用都会创建栈帧，调用了N次，每个栈帧使用了常数个空间O（1），其整体的空间复杂度为：
$O （ N ）$

四、Leetcode刷题

1. 消失的数

消失的数
在这里插入图片描述
思路一：排序 --> 对于示例输入：0 1 3，后一个数比前一个数大一就说明找到了
这个思路可行，但不符合提议为O（n）
排序 --> 最快排序O（N * logN），不符合。

思路2：把0到n的所有整数加到一起，结果为ret1，把输入示例中数组的数加到一起，结果为ret2，用ret1减去ret2，得到的结果就是所缺失的数。

int missingNumber(int* nums, int numsSize){
    int ret1 = 0;
    // 缺失一个数，那么0到n的所有数的个数就是numsSize的个数加1
    for(int i = 0; i < numsSize + 1; i++)
    {
        ret1 += i;  // 计算0到n之间所有的数的和
    }
    int ret2 = 0;
    for(int j = 0; j < numsSize; j++)
    {
        ret2 += nums[j];  // 计算数组nums中所有数的和
    }
    return ret1 - ret2;
}

在这里插入图片描述

思路3：按位异或，两个数按位异或（二进制），相同为0，相异为1，两个相同的数按位异或得到的就是0，另外，异或是支持交换律的，这意味着不需要排序直接依次异或即可。我们把从0到n之间的所有数与数组中的数依次按位异或，相同的数按位异或直接就等于0，最后得到的结果就是缺失的数。

int missingNumber(int* nums, int numsSize){
    int n = 0;
    for(int i = 0; i < numsSize; i++)
    {
    	// 先跟数组中的数异或
        n ^= nums[i]; // 0异或任何数还是原来那个数 
    }
    for(int j = 0; j < numsSize + 1; j++)
    {
    	// 在跟[0,n]之间所有的数异或
        n ^= j;
    }
    return n;
}

在这里插入图片描述

2. 旋转数组

旋转数组
在这里插入图片描述
题意：输入一个数k，将数组中的每个元素向右移动k位，数组的最后一个元素向右移动移位后就成了数组的第一个元素。

思路一：旋转k次，给一个变量tmp用于存数组的最后一个元素，从数组的最后一个元素开始，与他的前面一个元素互换，然后将tmp赋值给数组的首元素，这是旋转一次的过程，最后循环k次就可以了。
缺陷：Leetcode中有些测试样例将数组给的特别大，跑不过。
在这里插入图片描述
这种算法的时间复杂度为O（N * K）

思路二：以空间换时间，创建一个和nums同样大的数组，将nums数组的后k位元素与前k位元素进行互换，然后在将新数组中的元素拷贝到nums中。
缺陷：时间复杂度为O（N），空间复杂度为O（N），与题意不相符。

思路三：后k个逆置，前n - k个逆置，最后在整体逆置。假设给定一个数组：[1，2，3，4，5，6，7]，k = 3，前k个逆置之后变成[1，2，3，4，7，6，5]，前n - k个逆置后变成[4，3，2，1，7，6，5]，最后在整体逆置后变成[5，6，7，1，2，3，4]，最后得到的结果就和测试样例中的一样啦。

样例中可能会出现k大于数组元素的个数，对k取数组大小的余数即可。

// 逆置操作
void Reverse(int *nums, int left, int right)
{
    while(left < right)
    {
        int tmp = nums[left];
        nums[left] = nums[right];
        nums[right] = tmp;
        left++;
        right--;
    }
}
void rotate(int* nums, int numsSize, int k) {
    if(k >= numsSize)
    {
        k %= numsSize;  // 如果k大于数组, 对k进行取模操作
    }
    // 数组后k个逆置
    Reverse(nums, numsSize - k, numsSize - 1);
    // 数组前n - k个逆置
    Reverse(nums, 0, numsSize - k - 1);
    // 数组整体逆置
    Reverse(nums, 0, numsSize - 1);
}