算法复杂度

数据结构

数据结构(DataStructure)是计算机存储、组织数据的⽅式，指相互之间存在⼀种或多种特定关系的数据元素的集合。没有⼀种单⼀的数据结构对所有⽤途都有⽤，所以我们要学各式各样的数据结构，如：线性表、树、图、哈希等

算法

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

一、算法效率

（1）复杂度的概念

算法在编写成可执⾏程序后，运⾏时需要耗费时间资源和空间(内存)资源。因此衡量⼀个算法的好坏，⼀般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。
时间复杂度主要衡量⼀个算法的运⾏快慢，⽽空间复杂度主要衡量⼀个算法运⾏所需要的额外空间。在计算机发展的早期，计算机的存储容量很⼩。所以对空间复杂度很是在乎。但是经过计算机⾏业的迅速发展，计算机的存储容量已经达到了很⾼的程度。所以我们如今已经不需要再特别关注⼀个算法的空间复杂度

（2）时间复杂度

定义：在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运⾏时间。时间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运⾏时间呢？
在这里插入图片描述
那么算法的时间复杂度是⼀个函数式T(N)到底是什么呢？这个T(N)函数式计算了程序的执⾏次数。通过c语⾔编译链接章节学习，我们知道算法程序被编译后⽣成⼆进制指令，程序运⾏，就是cpu执⾏这些编译好的指令，⽐如解决⼀个问题的算法a程序T(N)=N，算法b程序T(N)=N^2，那么算法a的效率⼀定优于算法b

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

Func1执⾏的基本操作次数： T(N) = N*N + 2 ∗N +10
实际中我们计算时间复杂度时，计算的也不是程序的精确的执⾏次数，精确执⾏次数计算起来还是很⿇烦的，所以我们只需要计算程序能代表增⻓量级的⼤概执⾏次数，复杂度的表⽰通常使⽤⼤O的渐进表⽰法

（3）⼤O的渐进表⽰法

在这里插入图片描述
**通过以上⽅法，可以得到 Func1 的时间复杂度为：O(N*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); 
}

Func2执⾏的基本操作次数：T(N) = 2N +10
但是由上面的⼤O阶规则可知Func2的时间复杂度为：O(N)
示例二：

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执⾏的基本操作次数：T(N) = M+N
但实际上当M<N或者M>N亦或者是M=N取其中一个即可，但如果说M>>N这样的话就只能取M了
示例三：
在这里插入图片描述
T(N) = 100
但根据上面的规则可知T(N)=1
示例四：

const char * strchr ( const char * str, int character)
 {
 const char* p_begin = str;
 while (*p_begin != character)
 {
 if (*p_begin == '\0')
 return NULL;
 p_begin++;
 }
 return p_begin;
 }

strchr执⾏的基本操作次数：
1）若要查找的字符在字符串第⼀个位置，则：T(N) = 1
2）若要查找的字符在字符串最后的⼀个位置，则：T(N) = N
3）若要查找的字符在字符串中间位置，则：T(N) =N/ 2
因此：strchr的时间复杂度分为：
最好情况： O(1)
最坏情况：O(N)
平均情况：O(N)
在这里插入图片描述
示例五：

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

1）若数组有序，则：T(N)=N
2)若数组无序，则：T（N）=N*(N-1)/2，所以最后就是O(N^N)
示例六：

void func5(int n)
 {
    int cnt = 1;
    while (cnt < n)
    {
        cnt *= 2;
    }
 }

在这里插入图片描述
当n接近⽆穷⼤时，底数的⼤⼩对结果影响不⼤。因此，⼀般情况下不管底数是多少都可以省略不写，即可以表⽰为log n
不同书籍的表⽰⽅式不同，以上写法差别不⼤，我们建议使⽤ log n
示例七：

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

调⽤⼀次Fac函数的时间复杂度为O(1)
⽽在Fac函数中，存在n次递归调⽤Fac函数
因此：阶乘递归的时间复杂度为： O(n)

二、空间复杂度

空间复杂度也是⼀个数学表达式，是对⼀个算法在运⾏过程中因为算法的需要额外临时开辟的空间。
空间复杂度不是程序占⽤了多少bytes的空间，因为常规情况每个对象⼤⼩差异不会很⼤，所以空间复杂度算的是变量的个数。
空间复杂度计算规则基本跟时间复杂度类似，也使⽤⼤O渐进表⽰法。
注意：函数运⾏时所需要的栈空间(存储参数、局部变量、⼀些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运⾏时候显式申请的额外空间来确定
示例一：

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

函数栈帧在编译期间已经确定好了，只需要关注函数在运⾏时额外申请的空间。
BubbleSort额外申请的空间有exchange等有限个局部变量，使⽤了常数个额外空间
因此空间复杂度为 O(1)
示例二：

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

Fac递归调⽤了N次，额外开辟了N个函数栈帧，每个栈帧使⽤了常数个空间。因此空间复杂度为：O(N)

三、复杂度算法题

https://leetcode.cn/problems/rotate-array/description/
思路一
时间复杂度 O(n*n )

void rotate(int* nums, int numsSize, int k) {
 while(k--)
 {
 int end = nums[numsSize-1];
 for(int i = numsSize - 1;i > 0 ;i--)
 {
 nums[i] = nums[i-1];
 }
 nums[0] = end;
 }
 }

示例二：
空间复杂度 O(n)
申请新数组空间，先将后k个数据放到新数组中，再将剩下的数据挪到新数组中

 void rotate(int* nums, int numsSize, int k) 
{
 int newArr[numsSize];
 for (int i = 0; i < numsSize; ++i) 
{
 newArr[(i + k) % numsSize] = nums[i];
 }
 for (int i = 0; i < numsSize; ++i) 
{
 nums[i] = newArr[i];
 }
 }

时间复杂度不同于空间复杂度，时间复杂度要看循环次数来决定的，但空间复杂度却只用看定义的变量的个数，但它们两者相同的地方就是往最坏的地方考虑，例如在上面的代码中就当作是定义了一个含有N个元素的数组，那一个数组元素开辟一个内存空间，因此其空间复杂度就是N

思路3：
空间复杂度 O(1)
这个方法叫做三逆序法
• 前n-k个逆置：5 6 7 4 3 2 1
• 后k个逆置：4 3 2 1 7 6 5
• 整体逆置： 5 6 7 1 2 3 4

void reverse(int* nums,int begin,int end)
 {
 while(begin<end){
 int tmp = nums[begin];
 nums[begin] = nums[end];
 nums[end] = tmp;
 begin++;
 end--;
 }
 }
 void rotate(int* nums, int numsSize, int k)
 {
 k = k%numsSize;
 reverse(nums,0,numsSize-k-1);
 reverse(nums,numsSize-k,numsSize-1);
 reverse(nums,0,numsSize-1);
 }