Conceptos básicos de Python: complejidad del algoritmo

1. La complejidad del algoritmo se refiere a: después de escribir el algoritmo en un programa ejecutable, los recursos necesarios para el tiempo de ejecución, los recursos incluyen recursos de tiempo y recursos de memoria.

2. La complejidad del algoritmo incluye: complejidad de tiempo, complejidad de espacio

3. Complejidad del tiempo: es decir, la eficiencia de ejecución del algoritmo, que se refiere a la relación entre el tiempo de ejecución del algoritmo y el valor de entrada del algoritmo. Generalmente se representa con una gran O. Enfóquese principalmente en el bucle for\while. Al escribir código, considere cómo reducir los bucles

def test1(n):
    count=0            #a
    for i in range(n):
        count+=i       #b
    return count       #c

# 如上，这个函数，运行时间包括 a,b,c三部分，
# 对于整个函数来说，a，c执行一次，可以忽略不计，b循环部分时间，由输入值n决定，会循环n次，是一个标准的O(n)的复杂度

4. Complejidad de tiempo común: O(1)<O(logN)<O(N)<O(NlogN)<O(n elevado a la 2ª potencia)<O(2 elevado a la nésima potencia)<O(n! )

5. Caso de complejidad temporal:

5.1 

# 案例O(1)：无循环
def o1(n):
    i=n
    k=n*2
    return i+k

5.2

# 案例O(logN)：while循环
# i一直在变，那么while条件也一直在变，log2(n)：log以2为底，n的对数
def o_log_n(n):
    i=1          #a
    while i<n:
        i=i*2    #b
    return i     #c

5.3

# 案例O(N)：for循环
# O(M+N)两个for循环
def OMN(n,m):
    count=0
    for i in range(m):
       count +=i
    for j in range(n):
        count +=j
    return count

5.4

# 案例：O(NlogN)：for循环嵌套while循环
def ONLogN(m,n):
    count=0
    j=0
    for i in range(m):
        while j<n:
            count +=i+j
            j=j+2
    return  count

5.5 

# 案例：O(n的平方)：for循环嵌套for循环。

def ON2(n):
    count=0
    for i  in range(n):
        for j in range(n):
            count=i+j
    return count

6. Complejidad del espacio: la relación entre el espacio de almacenamiento del algoritmo y el valor de entrada

7. Complejidad del espacio común: O(1)<O(N)

8. Caso de complejidad espacial:

8.1 Defina una variable de conteo de tipo int, un int tiene 4 bytes. En el siguiente ejemplo, no importa cuántas veces se ejecute el ciclo for, el contenido de count cambia, el espacio ocupado por count no cambia, return count solo se ejecuta una vez y finaliza después de la ejecución. La complejidad del espacio es O(1)

def test2(n):
    count=0;
    for i in range(n):
        count+=i
    return count

8.2 Defina una matriz, agregue un byte sin agregar un valor, que es un aumento lineal. La complejidad del espacio es O(N)

def test3(n):
    array=[]
    for i in n:
        array.append(i)
    return array