Vitajte na [www.pocitac.win] Pripojiť k domovskej stránke Obľúbené stránky
Tu je rozpis spoločných scenárov a ich zložitosť runtime:
1. Konštantný čas (o (1))
* Keď slučka spustí pevné, málo krát bez ohľadu na veľkosť vstupu. Je to zriedkavé, ale mohlo by sa to stať, ak stav slučky závisí od konštantnej hodnoty a nie je ovplyvnený vstupom.
`` `Python
i =0
Zatiaľ čo som <5:# slučky presne 5 -krát
tlač (i)
i +=1
`` `
2. Logaritmický čas (o (log n))
* Keď slučka zmenšuje veľkosť problému konštantným faktorom v každej iterácii. Klasickým príkladom je binárne vyhľadávanie.
`` `Python
nízko =0
vysoký =n - 1
zatiaľ čo nízka <=vysoká:# slučka pokračuje tak dlho, ako existuje vyhľadávací priestor
mid =(nízka + vysoká) // 2
Ak ARR [mid]
elif arr [mid]> cieľ:
vysoký =stredný - 1
inak:
Vráťte sa Mid # Cieľ nájdené!
`` `
Tu je veľkosť priestoru vyhľadávania (od „nízky“ po „vysoký“) v každej iterácii zhruba na polovicu. Preto slučka prebieha približne `log2 (n)` časy.
3. Lineárny čas (o (n))
* Keď slučka iterová cez každý prvok vstupu veľkosti `n` raz. To je veľmi bežné.
`` `Python
i =0
Zatiaľ čo som
i +=1
`` `
V tomto prípade telo slučky vykonáva „n` časy.
4. Kvadratický čas (o (n^2))
* Keď slučka iterová `n` časy pre každý z prvkov` n` (často vnorené slučky).
`` `Python
i =0
zatiaľ čo ja
zatiaľ čo j
J +=1
i +=1
`` `
Zahŕňa to vnorenú „slučku“, kde obidve slučky iterujú `n` časy. Celkový počet iterácií je `n * n =n^2`.
5. Iný polynomický čas (o (n^k))
* Zovšeobecnenie vyššie uvedeného kvadratického príkladu. Napríklad tri vnorené slučky, ktoré každé iterované „n` krát by viedli k zložitosti O (n^3).
6. Exponenciálny čas (o (2^n)) alebo horšie
* Čas vykonávania slučky rastie exponenciálne s veľkosťou vstupu. To často naznačuje zle navrhnutý algoritmus alebo problém, ktorý je vo svojej podstate veľmi ťažký. Príklady môžu zahŕňať vyskúšanie všetkých možných kombinácií prvkov.
Kľúčové úvahy:
* Vstupná veľkosť (n): Čo predstavuje `n`? Veľkosť poľa, veľkosť čísla atď. Je to rozhodujúce pre vyjadrenie zložitosti z hľadiska vstupu.
* zmeny premenných podmienok: Ako sa mení premenná (meradlá) riadiace podmienky slučky v slučke? Zvyšuje sa o konštantné množstvo, znižuje sa o faktor atď.?
* Operácie vo vnútri slučky: Runtime operácií * vo vnútri * záleží na slučke. Ak napríklad máte O (n) operáciu vo vnútri slučky, ktorá beží n krát, celková zložitosť je o (n * n) =o (n^2).
Ako určiť zložitosť runtime:
1. Identifikujte veľkosť vstupu (n): Aký je relevantný parameter veľkosti?
2. Určte počet iterácií: Koľkokrát sa slučka vykonáva *vo vzťahu k `n` *? Toto je hlavná časť.
3. Zvážte operácie vo vnútri slučky: Ak slučka obsahuje komplexné operácie, musí sa zohľadniť ich zložitosť runtime. Celková zložitosť sa stáva zložitosťou iterácií slučky vynásobená zložitosťou najdrahšej operácie v slučke.
4. vyjadruje zložitosť: Použite big o notáciu (o (), co (), θ ()), aby ste reprezentovali hornú hranicu, dolnú hranicu alebo tesnú hranicu behu. Zvyčajne sa zameriavame na Big O (najhorší scenár).
Príklad:
`` `Python
def process_array (ARR):
n =Len (ARR)
i =0
zatiaľ čo ja
zatiaľ čo j
arr [i], arr [j] =arr [j], arr [i] # konštantný čas swap
J +=1
i +=1
spiatočná ARR
`` `
analýza:
* `n` je dĺžka vstupného poľa` arr`.
* Vonkajšia slučka (`i`) beží` n` časy.
* Vnútorná slučka (`j`) prevádzkuje približne` n - i'' -krát. V najhoršom prípade, keď je `i` 0, beží` n` časy.
* Operácia swap vo vnútri vnútornej slučky je o (1).
Vnorené slučky preto prispievajú k zložitosti O (n^2). Swap je konštantný čas a nemá vplyv na celkový beh O (n^2). Tento algoritmus je podobný výberu výberu.
Stručne povedané, aby sa určila zložitosť runtime zložitosti slučky „while“, starostlivo analyzujte, koľkokrát sa slučka vykonáva v porovnaní s veľkosťou vstupu a zvážte zložitosť operácií vykonávaných v slučke.