Què és la notació Big-O?

Què és la notació Big-O?

Us heu preguntat mai per què un programa que vau escriure trigava tant a funcionar? Potser voldríeu saber si podeu fer que el vostre codi sigui més eficient. Comprendre com s’executa el codi pot portar el vostre codi al següent nivell. La notació Big-O és una eina útil per calcular l’eficàcia del vostre codi.





Què és la notació Big-O?

La notació Big-O us proporciona una manera de calcular el temps que trigareu a executar el vostre codi. Físicament podeu calcular el temps que triga a executar-se el codi, però amb aquest mètode és difícil detectar petites diferències horàries. Per exemple, el temps que triga entre executar 20 i 50 línies de codi és molt petit. No obstant això, en un gran programa, aquestes ineficiències es poden sumar.



com fer fotos privades a Facebook 2018

La notació Big-O compta quants passos ha d’executar un algorisme per avaluar-ne l’eficiència. Aproximar-vos al vostre codi d’aquesta manera pot ser molt eficaç si heu d’ajustar el vostre codi per augmentar l’eficiència. La notació Big-O us permetrà mesurar diferents algoritmes pel nombre de passos que necessiteu per executar i comparar objectivament l’eficiència dels algorismes.





Com es calcula la notació Big-O

Considerem dues funcions que expliquen quants mitjons individuals hi ha en un calaix. Cada funció pren el nombre de parells de mitjons i retorna el nombre de mitjons individuals. El codi està escrit en Python, però això no afecta la forma en què comptem el nombre de passos.

Algorisme 1:



def sockCounter(numberOfPairs):
individualSocks = 0
for x in range(numberOfPairs):
individualSocks = individualSocks + 2
return individualSocks

Algorisme 2:

def sockCounter(numberOfPairs):
return numberOfPairs * 2

Aquest és un exemple ximple i hauríeu de poder saber fàcilment quin algorisme és més eficient. Però, per a la pràctica, passem per cadascun d’ells.



RELACIONATS: Què és una funció en la programació?

L'algorisme 1 té molts passos:



  1. Assigna un valor zero a la variable individualSocks.
  2. Assigna un valor d’un a la variable i.
  3. Compara el valor d’i amb numberOfPairs.
  4. N’afegeix dos a mitjons individuals.
  5. S'assigna el valor augmentat dels mitjons individuals a si mateix.
  6. Incrementa i per un.
  7. A continuació, torna a passar pels passos 3 a 6 durant el mateix nombre de vegades que (indiviualSocks - 1).

El nombre de passos que hem de completar per a l'algorisme es pot expressar com:

4n + 2

Hi ha quatre passos que hem de completar n vegades. En aquest cas, n seria igual al valor de numberOfPairs. També hi ha dos passos que es completen una vegada.

En comparació, l'algorisme 2 només té un pas. El valor de numberOfPairs es multiplica per dos. Ho expressaríem com:

1

Si encara no era evident, ara podem veure fàcilment que l'algorisme 2 és bastant més eficient.

Anàlisi Big-O

En general, quan us interessa la notació Big-O d’un algorisme, us interessa més l’eficiència general i menys l’anàlisi de gra fi del nombre de passos. Per simplificar la notació, només podem afirmar la magnitud de l’eficiència.

En els exemples anteriors, l'algorisme 2 s'expressaria com un:

O(1)

Però l'algorisme 1 es simplificaria com:

O(n)

Aquesta instantània ràpida ens explica com l’eficiència de l’algorisme es relaciona amb el valor de n. Com més gran sigui el nombre, més passos haurà de completar l'algorisme.

Codi lineal

Crèdit de la imatge: Nick Fledderus / Projecte de noms

Com que no sabem el valor de n, és més útil pensar com afecta el valor de n la quantitat de codi que cal executar. A l’algorisme 1 podem dir que la relació és lineal. Si traçeu el nombre de passos i el valor de n, obtindreu una línia recta que puja.

Codi quadràtic

No totes les relacions són tan simples com l’exemple lineal. Imagineu que teniu una matriu 2D i voleu cercar un valor a la matriu. Podeu crear un algorisme com aquest:

def searchForValue(targetValue, arraySearched):
foundTarget = False
for x in arraySearched:
for y in x:
if(y == targetValue):
foundTarget = True
return foundTarget

En aquest exemple, el nombre de passos depèn del nombre d'arrays a arraySearched i del nombre de valors de cada array. Per tant, el nombre simplificat de passos seria n * n o n².

quina és la zona d'aplicacions

Crèdit de la imatge: Nick Fledderus / Projecte de noms

Aquesta relació és una relació quadràtica, el que significa que el nombre de passos del nostre algorisme creix exponencialment amb n. A la notació Big-O, l’escriuríeu com a:

O(n²)

RELACIONATS: Eines útils per comprovar, netejar i optimitzar fitxers CSS

Codi logarítmic

Tot i que hi ha moltes altres relacions, l’última relació que analitzarem són les relacions logarítmiques. Per actualitzar la memòria, el registre d'un número és el valor de l'exponent que es necessita per arribar a un número donat una base. Per exemple:

log 2 (8) = 3

El registre és igual a tres perquè si la nostra base fos 2, necessitaríem un valor d’exponent de 3 per arribar al número 8.

Crèdit de la imatge: Nick Fledderus / Projecte de noms

Per tant, la relació d’una funció logarítmica és el contrari d’una relació exponencial. A mesura que n augmenta, es necessiten menys passos nous per executar l'algorisme.

A primera vista, sembla contraintuïtiu. Com es poden fer els passos d’un algoritme més lents que n? Un bon exemple d’això són les cerques binàries. Considerem un algorisme per cercar un número en una matriu de valors únics.

  • Començarem per una matriu de cerca que sigui de l'ordre del més petit al més gran.
  • A continuació, comprovarem el valor al mig de la matriu.
  • Si el vostre número és superior, exclourem els números més baixos de la nostra cerca i, si el nombre era inferior, exclourem els números més elevats.
  • Ara veurem el nombre mitjà dels números restants.
  • Una vegada més, exclourem la meitat dels números en funció de si el valor objectiu és superior o inferior al valor mitjà.
  • Continuarem aquest procés fins que no trobem el nostre objectiu o determinem que no apareix a la llista.

Com podeu veure, atès que les cerques binàries eliminen la meitat dels valors possibles a cada pas, a mesura que n es fa més gran, l’efecte sobre el nombre de vegades que comprovem la matriu amb prou feines es veu afectat. Per expressar-ho en notació Big-O, escriuríem:

O(log(n))

La importància de la notació Big-O

Big-O nation us proporciona una manera ràpida i senzilla de comunicar l’eficàcia d’un algorisme. Això fa que sigui més fàcil decidir entre diferents algoritmes. Això pot resultar particularment útil si utilitzeu un algorisme d'una biblioteca i no necessàriament sabeu com és el codi.

com es fa un filtre Snapchat personalitzat

Quan primer apreneu a codificar, comenceu per funcions lineals. Com podeu veure al gràfic anterior, us portarà molt lluny. Però a mesura que es fa més experimentat i es comença a construir codi més complex, l’eficiència comença a convertir-se en un problema. La comprensió de com quantificar l’eficiència del vostre codi us proporcionarà les eines que necessiteu per començar a ajustar-lo per obtenir més eficiència i ponderar els pros i els contres dels algorismes.

Compartir Compartir Tweet Correu electrònic 10 errors de programació i codificació més habituals

Els errors de codificació poden provocar tants problemes. Aquests consells us ajudaran a evitar errors de programació i a mantenir el vostre codi significatiu.

Llegiu a continuació Temes relacionats
  • Programació
  • Programació
Sobre l'autor Jennifer Seaton(21 articles publicats)

J. Seaton és un escriptor científic especialitzat en la descomposició de temes complexos. És doctora per la Universitat de Saskatchewan; la seva investigació es va centrar a utilitzar l'aprenentatge basat en jocs per augmentar la implicació dels estudiants en línia. Quan no treballa, la trobareu amb ella llegint, jugant a videojocs o fent jardineria.

Més de Jennifer Seaton

Subscriu-te al nostre butlletí

Uniu-vos al nostre butlletí per obtenir consells tècnics, ressenyes, llibres electrònics gratuïts i ofertes exclusives.

Feu clic aquí per subscriure-us