（数据结构）复杂度

基本概念说明

数据结构

定义：数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在⼀种或多种特定关系的数据元素的集合。没有⼀种单⼀的数据结构对所有用途都有用（要考虑适配、效率问题，在不同情况下使用合适的数据结构提高效率）

如：线性表、树、图、哈希等
功能：

存储数据
组织数据：增删改查数据

算法

定义：算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

算法都有好坏之分------就由复杂度来衡量

而数据结构和算法是不分家的

复杂度引入

我们来做一道算法题

https://leetcode.cn/problems/rotate-array/description/

自测运行通过，但是提交后的样例测试没有全部通过------代码所使用的算法不够好？

我们是否可以通过一些清晰的表达方法明确地表示算法的好坏呢？

复杂度的概念

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量⼀个算法的好坏，⼀般是从时间和空间 两个维度来衡量的，即时间复杂度和空间复杂度。

时间复杂度主要衡量**⼀个算法的运行快慢** ，而空间复杂度主要衡量⼀个算法运⾏所需要的额外空间 。

在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很⾼的程度。所以我们如今已经不需要再特别关注⼀个算法的空间复杂度。

（但是我们也不能随意浪费空间！）

时间复杂度和空间复杂度都使用大O的渐进表示法来表示，复杂度是一个函数式。

大O的渐进表示法

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

推导大O阶规则

复杂度函数式T(N)中，只保留最高阶项，去掉那些低阶项，因为当N不断变大时，低阶项对结果影响越来越⼩，当N无穷时，就可以忽略不计了。
如果最高阶项存在且不是1，则去除这个项目的常数系数，因为当N不断变大，这个系数对结果影响越来越小，当N无穷大时，就可以忽略不计了。
T(N)中如果没有N相关的项目，只有常数项，用常数1取代所有加法常数。

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

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

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

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

大O的渐进表示法在实际中⼀般情况关注的是算法的上界，也就是最坏运行情况。

时间复杂度运算

在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运⾏时间。

实际中我们计算时间复杂度时，计算的也不是程序的精确的执⾏次数，精确执⾏次数计算起来还是很⿇烦的(不同的⼀句程序代码，编译出的指令条数都是不⼀样的)，计算出精确的执⾏次数意义也不⼤，因为我们计算时间复杂度只是想⽐较算法程序的增⻓量级，也就是当N不断变⼤时T(N)的差别，当N不断变⼤时，常数和低阶项对结果的影响很⼩，所以我们只需要计算程序能代表增⻓量

级的⼤概执⾏次数，复杂度的表⽰通常使⽤⼤O的渐进表⽰法。

空间复杂度运算

空间复杂度也是⼀个数学表达式，是对⼀个算法在运⾏过程中因为算法的需要额外临时开辟的空间。空间复杂度不是程序占⽤了多少bytes的空间，因为常规情况每个对象⼤⼩差异不会很⼤，所以空间复杂度算的是变量的个数 。

空间复杂度计算规则基本跟实践复杂度类似，也使⽤⼤O渐进表⽰法。

注意：函数运⾏时所需要的栈空间(存储参数、局部变量、⼀些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运⾏时候显式申请的额外空间来确定 。

常见复杂度对比

复杂度算法题

最后我们再回到一开始的算法题

法一

审视一下最开始的算法的时间复杂度------O(n^2)。

c 复制代码

void rotate(int* nums, int numsSize, int k) {
    while(k--){
        int i=1;
        int tmp=nums[numsSize-1];
        for(int i=numsSize-1;i>0;i--)//注意替换元素的方向！
            nums[i]=nums[i-1];
        nums[0]=tmp;
    }
}

这种算法由于超出时间限制导致测试不通过，就是因为时间复杂度太高，所以现在我们需要进行优化、或者想出其他时间复杂度更低算法来解决问题。

法二：重新创建一个新数组，把nums中的元素按规律重新安置------只需要遍历一次nums数组就可完成------时间复杂度O(n)

(只要有思路，写具体代码之前就可以把时间复杂度写出来了）

c 复制代码

void rotate(int* nums, int numsSize, int k) {
    int newArray[numsSize];
    for(int i=0;i<numsSize;i++){
        newArray[(i+k)%numsSize]=nums[i];
        //巧用取模解决越界问题，不需要if语句分类讨论了
    }
    //将新数组导入到原数组中
    for(int j=0;j<numsSize;j++){
        nums[j]=newArray[j];
    }
}

空间复杂度是O(n)，因为运行时开辟临时变量数组另外申请了numsSize个int的空间，而反观最开始的方法一，空间复杂度为O(1)

所以我们称法二是一种"用时间换空间"的方法。

法三：三次逆置

c 复制代码

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) {
    reverse(nums,0,numsSize-k-1);
    reverse(nums,numsSize-k,numsSize-1);
    reverse(nums,0,numsSize-1);
}

但是这样写的代码运行是正确的，但是不是所有样例都通过

看上图分析可以得出，这是因为当k>numsSize时，这种方法会导致反转时出现数组编号为负数的越界问题。

只需要多写一句k%=numsSize即可避免越界情况。

c 复制代码

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) {
    k%=numsSize;
    reverse(nums,0,numsSize-k-1);
    reverse(nums,numsSize-k,numsSize-1);
    reverse(nums,0,numsSize-1);
}

此算法

时间复杂度：O(n)

空间复杂度：O(1)