Como calcular a complexidade do tempo e a complexidade do espaço?
Algoritmo de derivação: método de derivação Big O
1、用常数1取代运行时间中的所有加法常数
2、在修改后的运行次数函数中，只保留最高阶项
3、如果最高阶项存在且不是1，那么我们就去除于这个项相乘的常数。
complexidade de tempo
definição
Ao analisar o algoritmo, os tempos totais de execução T(n) da instrução são uma função do tamanho do problema n, e então analisar a variação de T(n) com n e determinar a magnitude de T(n). A complexidade de tempo do algoritmo, ou seja, a medição do tempo do algoritmo, é registrada como: T(n}=0(f(n)). Isso significa que com o aumento do tamanho do problema n, o tempo de execução do algoritmo aumenta e f(n ) tem a mesma taxa de crescimento, que é chamada de complexidade de tempo assintótica do algoritmo, ou complexidade de tempo para abreviar.Entre elas, f(n) é uma certa função da especificação do problema n.
ordem constante
void main()
{
func();
}
void func()
{
int i=0;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
}
/*
共执行了4次，所以时间复杂度为O(4);根据大O推导法，略去常数，所以此函数的时间复杂度为O(1);
*/
//假如func变成如下结构
void func()
{
int i=0;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
i++;//执行1次
}
/*
共执行了13次，时间复杂度为O(13);根据大O推导法，略去常数，所以此函数的时间复杂度仍然为O(1);
*/
ordem linear
void main()
{
for(int i=0;i<n;i++)
{
func();
}
}
void func()//时间复杂度为O(1)的函数
{
printf("大O推导法");//执行1次
}
/*
在main中，func共被执行了n次，所以main的时间复杂度为O(n);
*/
//加入main函数被修改成如下
void main()
{
for(int i=0;i<n;i++)
{
func();
func();
}
}
/*
在main中，func共被执行了2n次，main的时间复杂度为O(2n);根据大O推导法，略去常数系数，所以main的时间复杂度仍为为O(n);
*/
ordem logarítmica
void main()
{
for(int i=1;i<n;i++)
{
func();
i=2i;
}
}
void func()//时间复杂度为O(1)的函数
{
printf("大O推导法");//执行1次
}
/*
在main中，
因为i每次被乘2，所以，执行的算法为 2的几次相乘 大于 n，即 2^x>n,--> x= log2n , 在推导对数时间复杂度时，一般都是以10作为对数的底数。 func共被执行了logn次，所以main的时间复杂度为O(logn);
*/
ordem quadrada
void main()
{
for(int i=1;i<n;i++)
{
for(int j=1;j<n;j++)
{
func();
}
}
}
void func()//时间复杂度为O(1)的函数
{
printf("大O推导法");//执行1次
}
/*
在main中， func()共被执行了n^2,所以main的时间复杂度为O(n^2);
*/
//假如main被修改成 如下
void main()
{
for(int i=1;i<n;i++)
{
for(int j=i;j<n;j++)
{
func();
}
}
}
/*
那么， func() 执行的次数为 n+n-1+n-2+……--> n(n+1)/2 = n2/2 + n/2 根据大O推导方法，保留最高阶项，n2/2 ，然后去掉这个项相乘的常数，1/2， 所以main的时间复杂度为O(n2)
*/
resumo
O tempo gasto na complexidade do tempo é:
O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) <O(2n) < O(n!) < O (nn)
Referência https://www.cnblogs.com/fanchangfa/p/3868696.html
complexidade do espaço
definição
Enciclopédia Baidu: Complexidade Espacial (Space Complexity) é uma medida do tamanho do espaço de armazenamento ocupado temporariamente por um algoritmo durante a operação, registrado como S(n)=O(f(n)). Por exemplo, a complexidade de tempo da classificação por inserção direta é O(n^2) e a complexidade de espaço é O(1). O algoritmo recursivo geral terá uma complexidade de espaço de O(n), porque as informações de retorno devem ser armazenadas para cada recursão. Os prós e contras de um algoritmo são medidos principalmente a partir de dois aspectos: o tempo de execução do algoritmo e o espaço de armazenamento que ele precisa ocupar.
O algoritmo é semelhante à complexidade de tempo, exceto que o cálculo não é o número de execuções, mas o número de vezes que a variável temporária é usada durante a execução.
Referência https://www.cnblogs.com/irenebbkiss/p/4243715.html