Mi az a Big-O jelölés?

Mi az a Big-O jelölés?

Gondolkodtál már azon, miért tartott olyan sokáig az általad írt program futtatása? Talán szeretné tudni, hogy hatékonyabbá teheti -e a kódot. A kódfuttatás megértése a következő szintre emelheti a kódot. A Big-O jelölés egy praktikus eszköz annak kiszámításához, hogy a kód valóban mennyire hatékony.





Mi az a Big-O jelölés?

A Big-O jelölés segítségével kiszámíthatja, mennyi ideig tart a kód futtatása. Fizikailag meghatározhatja, hogy mennyi ideig tart a kód futtatása, de ezzel a módszerrel nehéz észrevenni a kis időbeli különbségeket. Például a 20 és 50 soros kód futtatása közötti idő nagyon kicsi. Egy nagy programban azonban ezek a hatástalanságok összeadódhatnak.



hogyan lehet privát fotókat készíteni a Facebookon 2018

A Big-O jelölés számolja, hogy az algoritmusnak hány lépést kell végrehajtania a hatékonyság felméréséhez. A kód ilyen módon történő megközelítése nagyon hatékony lehet, ha a hatékonyság növelése érdekében be kell hangolni a kódot. A Big-O jelölés lehetővé teszi a különböző algoritmusok mérését a futtatáshoz szükséges lépések számával és az algoritmusok hatékonyságának objektív összehasonlítását.





Hogyan kell kiszámítani a Big-O jelölést?

Tekintsünk két olyan funkciót, amelyek számolják, hány egyéni zokni van egy fiókban. Mindegyik függvény veszi a zoknipárok számát, és visszaadja az egyes zoknik számát. A kód Python -ban van írva, de ez nem befolyásolja, hogyan számolnánk a lépések számát.

1. algoritmus:



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

2. algoritmus:

def sockCounter(numberOfPairs):
return numberOfPairs * 2

Ez egy buta példa, és könnyen meg kell tudnia mondani, melyik algoritmus a hatékonyabb. De a gyakorlat kedvéért nézzük végig mindegyiket.



ÖSSZEFÜGGŐ: Mi a funkció a programozásban?

Az 1. algoritmusnak több lépése van:



  1. Nulla értéket rendel az individualSocks változóhoz.
  2. Egy értéket rendel az i változóhoz.
  3. Összehasonlítja az i értékét a numberOfPairs.
  4. Kettőt ad hozzá az individualSockshoz.
  5. Magának rendeli az individualSocks megnövelt értékét.
  6. Ez eggyel növeli az i -t.
  7. Ezután a 3–6. Lépésen keresztül ugyanannyiszor visszatér, mint az (indiviualSocks - 1).

Az első algoritmus végrehajtásához szükséges lépések számát a következőképpen lehet kifejezni:

4n + 2

Négy lépést kell n -szer elvégeznünk. Ebben az esetben n megegyezik a numberOfPairs értékével. Van 2 lépés is, amelyeket egyszer kell elvégezni.

Ehhez képest a 2 -es algoritmusnak csak egy lépése van. A numberOfPairs értékét meg kell szorozni kettővel. Ezt így fejeznénk ki:

1

Ha ez még nem volt nyilvánvaló, most könnyen beláthatjuk, hogy a 2. algoritmus jóval hatékonyabb.

Nagy-O elemzés

Általában, ha érdekli az algoritmus Big-O jelölése, akkor jobban érdekli az általános hatékonyság, kevésbé a lépések számának finom szemcséje. A jelölés egyszerűsítése érdekében csak megállapíthatjuk a hatékonyság nagyságát.

A fenti példákban a 2. algoritmust egyként fejezzük ki:

O(1)

De az 1 -es algoritmus a következőképpen egyszerűsödne:

O(n)

Ez a gyors pillanatfelvétel megmutatja, hogy az első algoritmus hatékonysága hogyan kapcsolódik az n értékéhez. Minél nagyobb ez a szám, annál több lépést kell végrehajtania az algoritmusnak.

Lineáris kód

Kép jóváírása: Nick Fledderus/ Főnévi projekt

Mivel nem ismerjük n értékét, hasznosabb elgondolkodni azon, hogy n értéke hogyan befolyásolja a futtatandó kód mennyiségét. Az 1. algoritmusban azt mondhatjuk, hogy a kapcsolat lineáris. Ha ábrázolja a lépések számát az n értékével, akkor egyenes vonal lesz, amely felfelé megy.

Másodfokú kód

Nem minden kapcsolat olyan egyszerű, mint a lineáris példa. Képzelje el, hogy van 2D tömbje, és szeretne keresni egy értéket a tömbben. Létrehozhat egy ilyen algoritmust:

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

Ebben a példában a lépések száma függ az arraySearched tömbök számától és az egyes tömbök értékeinek számától. Tehát az egyszerűsített lépések száma n * n vagy n².

windows xp ingyenesen letölthető PC -re

Kép jóváírása: Nick Fledderus/ Főnévi projekt

Ez a kapcsolat másodfokú összefüggés, ami azt jelenti, hogy algoritmusunk lépéseinek száma n -nel exponenciálisan növekszik. A Big-O jelölésben a következőképpen írná:

O(n²)

ÖSSZEFÜGGŐ: Hasznos eszközök a CSS fájlok ellenőrzéséhez, tisztításához és optimalizálásához

Logaritmikus kód

Bár sok más kapcsolat is létezik, az utolsó kapcsolat, amelyet megvizsgálunk, a logaritmikus kapcsolatok. A memória frissítéséhez a számok naplója az a kitevő érték, amely szükséges ahhoz, hogy egy bázist adott szám elérhessen. Például:

log 2 (8) = 3

A napló hárommal egyenlő, mert ha a bázisunk 2 lenne, akkor a 8 -as szám eléréséhez 3 kitevő értékre lenne szükségünk.

Kép jóváírása: Nick Fledderus/ Főnévi projekt

Tehát a logaritmikus függvény kapcsolata az exponenciális kapcsolat ellentéte. Az n növekedésével kevesebb új lépésre van szükség az algoritmus futtatásához.

Első pillantásra ez ellentétes intuitívnak tűnik. Hogyan nőhetnek egy algoritmus lépései lassabban, mint n? Jó példa erre a bináris keresések. Tekintsünk egy algoritmust egy szám keresésére egyedi értékek tömbjében.

  • Kezdjük a kereséssel, amely a legkisebbtől a legnagyobbig terjed.
  • Ezután ellenőrizni fogjuk a tömb közepén lévő értéket.
  • Ha a szám magasabb, akkor kizárjuk az alacsonyabb számokat a keresésből, és ha alacsonyabb volt, akkor a magasabb számokat.
  • Most megnézzük a fennmaradó számok középső számát.
  • Ismét kizárjuk a számok felét annak alapján, hogy a célértékünk magasabb vagy alacsonyabb, mint a középérték.
  • Ezt a folyamatot addig folytatjuk, amíg meg nem találjuk a célpontot, vagy nem állapítjuk meg, hogy nem szerepel a listában.

Amint láthatja, mivel a bináris keresések minden lehetséges szám felét kiküszöbölik minden egyes áthaladáskor, mivel n növekszik, a tömb ellenőrzésének számára gyakorolt ​​hatás alig van hatással. Ennek Big-O jelöléssel való kifejezésére a következőket írnánk:

O(log(n))

A Big-O jelölés fontossága

A Big-O nation gyors és egyszerű módot kínál az algoritmus hatékonyságának kommunikálására. Ez megkönnyíti a különböző algoritmusok közötti döntést. Ez különösen akkor lehet hasznos, ha könyvtárból származó algoritmust használ, és nem feltétlenül tudja, hogyan néz ki a kód.

hogyan ellenőrizheti a telefonszámát

Amikor először megtanul kódolni, a lineáris függvényekkel kezdi. Amint a fenti grafikonon látható, ez nagyon messzire vezet. De ahogy egyre tapasztaltabbá válsz, és bonyolultabb kódot kezdesz építeni, a hatékonyság kezd problémává válni. Ha megérti, hogyan kell számszerűsíteni a kód hatékonyságát, megadja azokat az eszközöket, amelyek szükségesek a hatékonyság beállításához, valamint az algoritmusok előnyeinek és hátrányainak mérlegeléséhez.

Részvény Részvény Csipog Email 10 leggyakoribb programozási és kódolási hiba

A kódolási hibák sok problémához vezethetnek. Ezek a tippek segítenek elkerülni a programozási hibákat és megtartani kódját.

Olvassa tovább Kapcsolódó témák
  • Programozás
  • Programozás
A szerzőről Jennifer Seaton(21 cikk megjelent)

J. Seaton tudományos író, aki összetett témák lebontására szakosodott. PhD fokozatot szerzett a Saskatchewan Egyetemen; kutatása a játékon alapuló tanulás felhasználására összpontosított, hogy növelje a diákok online elkötelezettségét. Amikor nem dolgozik, megtalálhatja őt olvasással, videojátékokkal vagy kertészkedéssel.

Bővebben: Jennifer Seaton

Iratkozzon fel hírlevelünkre

Csatlakozz hírlevelünkhöz, ahol technikai tippeket, véleményeket, ingyenes e -könyveket és exkluzív ajánlatokat találsz!

Feliratkozáshoz kattintson ide