数据结构——时间/空间复杂度

偏执的太偏执、 2024-03-31 14:57 16阅读 0赞

**目录**

算法效率：

时间复杂度：

例题：

附加知识：

冒泡排序的时间复杂度求解：

二分查找的时间复杂度求解：

复杂度对比图：

空间复杂度：

例题：

小结：

--------------------

## 算法效率： ##

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

### 时间复杂度： ###

> 时间复杂度的定义: 在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。**算法中的基本操作的执行次数，为算法的时间复杂。**

**推导大O阶方法：**

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

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

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

#### 例题： ####

**实例1：**

// 请计算一下Func1基本操作执行了多少次？
    void Func1(int N)
    {
     int count = 0;
     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);
    }

可知第一个循环执行n次，第二个循环执行n^2次，第三个循环执行10次。取它们中最高阶的数来代表时间复杂度。这个就相当于高数中的极限无穷小的比较。所以时间复杂度表示为O(N^2)。

**实例2：**

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

此程序需要执行2\*N+10次，根据第2、3项可知时间按复杂度为O(N)。

**实例3：**

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

这个便需要根据N和M的具体关系来判断时间复杂度。如果没有具体条件，时间复杂度便是O(N+M)。当N远大于M为O(N)。差不多的时候为O(M)/O(N)。

**实例4：**

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

若确定常数次，则为O(1)。

#### **附加知识：** ####

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

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

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

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

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

最好情况：1次找到

最坏情况：N次找到

平均情况：N/2次找到

在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为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;
     }
    }

最坏的情况便是冒泡排序的数列是最混乱的，每个数都需要交换。

第一次：N 第二次：N-1 第三次：N-2 …… 第N次：1。

所以我们发现这是一个等差数列：所以总次数为（N+1）\*N/2.**时间复杂度便为O(N^2).**

#### **二分查找的时间复杂度求解：** ####

// 计算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次 则1\*2\*2\*2……\*2=N 即2^X=N X=log2N。

因为很多地方不方便写底数，所以**时间复杂度便可以简写为O(logN)。**

#### **复杂度对比图：** ####

![b4f4c5cdeacb4adbabac82a2ab173fab.png][]

### 空间复杂度： ###

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

#### 例题： ####

![7e212a7b31334d37838ffd44928f21fe.png][]

可知其一共五个变量所以**空间复杂度为O(1)。**

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

递归调用了N层，每次调用建立一个栈帧，每个栈帧使用了常数个空间 ->0(1)  
调用时，建立栈帧；返回时，销毁。所以该程序**空间复杂度为O(N)。**

## **小结：** ##

**文章篇幅有限，故一些重点的算法题将在下一篇文章来说明，希望大家支持一下，给孩子个努力的动力！！！**

[b4f4c5cdeacb4adbabac82a2ab173fab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/4c2bcf01842741d5aebf2d45ab8d102c.png
[7e212a7b31334d37838ffd44928f21fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e7f331af92bd4c87bf71f6c234882299.png