Pokazuje, jak algorytm skaluje.

O (n²): znany jako złożoność kwadratowa

• 1 Pozycja: 1 sekunda
• 10 pozycji: 100 sekund
• 100 pozycji: 10000 sekund

Zauważ, że liczba przedmiotów wzrasta o współczynnik 10, ale czas wzrasta o współczynnik 10². Zasadniczo n=10 i tak O (n²) daje nam współczynnik skalowania n² czyli 10².

O (n): znany as złożoność liniowa

• 1 Pozycja: 1 sekunda
• 10 elementów: 10 sekund
• 100 pozycji: 100 sekund

Tym razem liczba przedmiotów zwiększa się o współczynnik 10, podobnie jak czas. N=10, a więc współczynnik skalowania O(n) wynosi 10.

O (1) : znana jako stała złożoności

• 1 Pozycja: 1 sekunda
• 10 items: 1 second
• 100 pozycji: 1 sekunda

Liczba pozycji jest nadal zwiększa się o współczynnik 10, ale współczynnik skalowania O (1) wynosi zawsze 1.

O (log n) : znany jako złożoność logarytmiczna

• 1 Pozycja: 1 sekunda
• 10 pozycji: 2 sekundy
• 100 pozycji: 3 sekundy
• 1000 pozycji: 4 sekundy
• 10000 pozycji: 5 sekund

Liczba obliczeń jest zwiększana tylko o dziennik wartości wejściowej. Tak więc w tym przypadku, zakładając, że każde obliczenie trwa 1 sekundę, log wejścia n jest wymagany czas, stąd log n.

Notacja Big-O (zwana także notacją asymptotyczną wzrostu) to jak wyglądają funkcje, gdy ignoruje się stałe czynniki i rzeczy w pobliżu źródła . Używamy go, aby porozmawiać o jak skala rzeczy.

Podstawy

Dla "wystarczająco" dużych wejść...

• f(x) ∈ O(upperbound) oznacza f "rośnie nie szybciej niż" upperbound
• f(x) ∈ Ɵ(justlikethis) mean f "rośnie dokładnie jak" justlikethis
• f(x) ∈ Ω(lowerbound) oznacza f "rośnie nie wolniej niż" lowerbound

Notacja Big-O nie dba o stałe czynniki: funkcja 9x² mówi się, że "rośnie dokładnie tak jak" 10x². Podobnie jak w notacji big-O asymptotyczne Nie-asymptotyczne rzeczy ("rzeczy w pobliżu źródła" lub "co się dzieje, gdy rozmiar problemu jest mały"): funkcja 10x² mówi się, że" rośnie dokładnie tak jak " 10x² - x + 2.

Dlaczego chcesz ignorować mniejsze części równania? Ponieważ stają się całkowicie karłowate przez duże części równania, jak wziąć pod uwagę większe i większe skale; ich wkład staje się karłowate i nieistotne. (Patrz przykładowa sekcja.)

Mówiąc inaczej, chodzi o stosunek kiedy zmierzasz do nieskończoności. jeśli podzielisz rzeczywisty czas jaki zajmuje przez O(...), otrzymasz stały współczynnik limitu dużych wejść. intuicyjnie ma to sens: funkcje "skalują się jak", jeśli można je pomnożyć, aby uzyskać drugi. To jest, kiedy mówimy...

actualAlgorithmTime(N) ∈ O(bound(N))
                                       e.g. "time to mergesort N elements 
                                             is O(N log(N))"

... oznacza to, że dla "wystarczająco dużych" rozmiarów problemu N (jeśli zignorujemy rzeczy w pobliżu źródła), istnieje pewna stała (np. 2.5, całkowicie zmyślona) taka, że: {]}

actualAlgorithmTime(N)                 e.g. "mergesort_duration(N)       "
────────────────────── < constant            ───────────────────── < 2.5 
       bound(N)                                    N log(N)         

Istnieje wiele możliwości wyboru stałej; często "najlepszy" wybór jest znany jako "stały czynnik" algorytmu... ale często ignorujemy to tak, jak ignorujemy Nie-największe terminy (zobacz sekcję stałe czynniki, dlaczego zwykle nie Materia). Można również myśleć o powyższym równaniu jako związanym, mówiąc " w najgorszym przypadku czas potrzebny nigdy nie będzie gorszy niż mniej więcej N*log(N), w przedziale 2,5 (stały czynnik, na którym nie dbamy)".

Ogólnie rzecz biorąc, O(...) jest najbardziej przydatny, ponieważ często dbamy o najgorsze zachowanie. Jeśli f(x) reprezentuje coś "złego", jak użycie procesora lub pamięci, to "f(x) ∈ O(upperbound) "oznacza" upperbound jest najgorszym scenariuszem procesora/pamięci użytkowania".

Aplikacje

Jako konstrukcja czysto matematyczna, notacja big-O nie ogranicza się do mówienia o czasie przetwarzania i pamięci. Można go użyć do omówienia asymptotyki wszystkiego, gdzie skalowanie ma znaczenie, na przykład:]}

• liczba możliwych uścisków dłoni wśród N osób na imprezie (Ɵ(N²), a konkretnie N(N-1)/2, ale liczy się to, że "skaluje się jak" N²)
• probabilistyczna oczekiwana liczba osób kto widział jakiś Marketing wirusowy jako funkcję czasu [124]} W 2009 roku firma została założona przez firmę Microsoft, która od 2009 roku zajmuje się produkcją i dystrybucją oprogramowania dla komputerów stacjonarnych.]}
• jak skaluje się moc cieplna procesora w funkcji liczby tranzystorów, napięcia itp.
• ile czasu algorytm musi uruchomić, jako funkcja wielkości wejściowej
• ile przestrzeni musi uruchomić algorytm, jako funkcja wejścia rozmiar

Przykład

Dla powyższego przykładu uścisku dłoni, każdy w pokoju podaje rękę innym. W tym przykładzie #handshakes ∈ Ɵ(N²). Dlaczego?

Cofnij się trochę: liczba uścisków dłoni jest dokładnie n-Wybierz-2 lub N*(N-1)/2 (każda z N osób potrząsa rękami N-1 innych osób, ale to podwójnie liczy uściski dłoni, więc podziel przez 2):

Jednakże, dla bardzo dużej liczby ludzi, termin liniowy N jest karłowaty i skutecznie przyczynia się do 0 do stosunku (na wykresie: ułamek pustych pól na przekątnej nad całkowitymi pola staje się mniejszy, gdy liczba uczestników staje się większa). Dlatego zachowanie skalowania wynosi order N², lub liczba uścisków dłoni "rośnie jak N2".

#handshakes(N)
────────────── ≈ 1/2
     N²

To tak, jakby puste pola na przekątnej wykresu(N*(N-1)/2 znaczniki kontrolne) nawet tam nie było (N² checkmarks asymptotically).

(dygresja czasowa z" zwykłego angielskiego":) jeśli chcesz to sobie udowodnić, możesz wykonać jakąś prostą algebrę na stosunku, aby podzielić ją na wiele terminów (lim oznacza "rozważany w granicach", po prostu zignoruj to, jeśli tego nie widziałeś, to tylko zapis dla "I N jest naprawdę naprawdę duże"): {]}

    N²/2 - N/2         (N²)/2   N/2         1/2
lim ────────── = lim ( ────── - ─── ) = lim ─── = 1/2
N→∞     N²       N→∞     N²     N²      N→∞  1
                               ┕━━━┙
             this is 0 in the limit of N→∞:
             graph it, or plug in a really large number for N

Tl; dr: liczba uścisków dłoni 'wygląda jak' x2 tak bardzo dla dużych wartości, że gdybyśmy mieli zapisać stosunek # uściski dłoni/x2, fakt, że nie potrzebujemy dokładnie x2 uściski dłoni nie pojawiłyby się nawet w układzie dziesiętnym przez arbitralnie dużą chwilę.

Np. dla x=1million, stosunek # handshakes / x2: 0.499999...

Intuicja Budynku

To pozwala nam wypowiedzieć się jak...

"dla wystarczająco dużego inputsize=N, bez względu na stały współczynnik, jeśli I double wielkość wejścia...

• ... I double the time an O (N) ("czas liniowy") algorytm zajmuje."

  N → (2N) = 2 (N )

• ... I double-squared(quadruple) czas o (N2) ("czas kwadratowy") algorytm zajmuje." (np. problem 100x jako duży zajmuje 1002=10000x jako długi... prawdopodobnie niezrównoważony)

  N2 → (2N)2 = 4(N2 )

• ... I double cubed(octuple) czas o (N3) ("czas sześcienny") algorytm zajmuje." (np. a problem 100x jako duży trwa 1003 = 1000000x tak długo... bardzo niezrównoważony)

  CN3 → c (2N)3 = 8(cN3)

• ... Dodaję stałą kwotę do czasu, jaki zajmuje algorytm o(log (N)) ("czas logarytmiczny")."(tanio!)

  C log (N) → C log (2N) = (c log(2))+(C log (N) ) = (stała kwota)+(c log (N))

• ... I don ' t change the time an O (1) ("constant czas")."(najtaniej!)

  C*1 → c*1

• ... I "(zasadniczo) podwoić " czas o(n log (N)) algorytm trwa." (dość często)

  To mniej niż O (N^1.000001), które można nazwać zasadniczo liniowym

• ... I śmiesznie zwiększyć czas o(2^N) ("czas wykładniczy") algorytm bierze." (you ' d podwójne (lub potrójne itp. 100%), co oznacza, że problem może być zwiększony o jedną jednostkę.]}

  2^N → 2^2N = (4^N )............inaczej mówiąc...... 2^N → 2^N+1 = 2^N2¹ = 2 2^N

(z kredytem na https://stackoverflow.com/a/487292/711085 )

Są to porządki wzrostu, które programiści i informatycy stosują jako punkty odniesienia. Widzą je cały czas. (Więc chociaż technicznie można myśleć "podwojenie wejścia powoduje, że algorytm O (√N) jest 1.414 razy wolniejszy," lepiej o tym myśleć jako "to jest gorsze niż logarytmiczne, ale lepsze niż liniowe".)

Czynniki stałe

Zwykle nie obchodzi nas, jakie są konkretne stałe czynniki, ponieważ nie wpływają one na sposób, w jaki funkcja rośnie. Na przykład dwa algorytmy mogą zająć O(N) czas, ale jeden może być dwa razy wolniejszy od drugiego. Zazwyczaj nie dbamy zbytnio, chyba że czynnik jest bardzo duży, ponieważ optymalizacja jest trudna ({347]} kiedy czy optymalizacja jest przedwczesna?); również sam akt wybierania algorytmu z lepszym big-O często poprawi wydajność o rzędy wielkości.

Niektóre asymptotycznie nadrzędne algorytmy (np. sortowanie nieporównawcze O(N log(log(N)))) mogą mieć tak duży stały współczynnik (np. 100000*N log(log(N))), lub narzut, który jest stosunkowo duży, jak O(N log(log(N))) Z Ukrytym + 100*N, że rzadko warto ich używać nawet na "dużych danych".

Dlaczego O (N) jest czasem najlepszym, co można zrobić, tzn. dlaczego potrzebujemy datastructures

O(N) algorytmy są w pewnym sensie" najlepszymi " algorytmami, jeśli trzeba odczytać wszystkie dane. samo odczytanie zbioru danych jest operacją O(N). Ładowanie go do pamięci jest zwykle O(N) (lub szybsze, jeśli masz wsparcie sprzętowe, lub w ogóle nie ma czasu, jeśli już przeczytałeś dane). Jeśli jednak dotkniesz lub nawet spojrzysz na każdy fragment danych (lub nawet każdy inny fragment danych), twój algorytm zajmie O(N) Czas aby wykonać to spojrzenie. Nomatter, jak długo trwa Twój rzeczywisty algorytm, będzie to co najmniej O(N), ponieważ spędził ten czas patrząc na wszystkie dane.

To samo można powiedzieć o samym akcie pisania. Wszystkie algorytmy, które drukują N rzeczy, zajmują N czasu, ponieważ wyjście jest co najmniej tak długie(np. drukowanie wszystkich permutacji (sposobów na zmianę układu) zbioru N kart do gry jest czynnikowe: O(N!)).

To motywuje wykorzystanie danych struktury : struktura danych wymaga odczytu danych tylko raz (zwykle O(N) Czas), plus pewna dowolna ilość wstępnego przetwarzania (np. O(N) lub O(N log(N)) lub O(N²)), które staramy się zachować w małych ilościach. Następnie modyfikowanie struktury danych (wstawianie / usuwanie / itp.) i wykonywanie zapytań o dane zajmuje bardzo mało czasu, np. O(1) lub O(log(N)). Następnie przystąpić do wielu zapytań! Ogólnie rzecz biorąc, im więcej pracy jesteś gotów wykonać z wyprzedzeniem, tym mniej pracy będziesz musiał później.

Na przykład, załóżmy, że masz współrzędne szerokości i długości milionów odcinków dróg i chciałeś znaleźć wszystkie skrzyżowania ulic.

• naiwna metoda: gdybyś miał współrzędne skrzyżowania ulic i chciał zbadać pobliskie ulice, musiałbyś przejść przez miliony segmentów za każdym razem i sprawdzić każdy z nich pod kątem przyległości.
• jeśli trzeba zrobić to tylko raz, to nie byłoby problemem, aby zrobić naiwnych metoda O(N) działa tylko raz, ale jeśli chcesz to zrobić wiele razy (w tym przypadku, N razy, raz dla każdego segmentu), będziemy musieli wykonać O(N²) pracę, lub 10000002=10000000000000 operacji. Niezbyt dobrze (nowoczesny komputer może wykonywać około miliarda operacji na sekundę).
• jeśli używamy prostej struktury zwanej tabelą hashową (tabelą szybkiego wyszukiwania, znaną również jako hashmap lub słownik), płacimy niewielki koszt, przetwarzając wszystko w czasie O(N). Następnie wystarczy średni czas na wyszukanie czegoś według klucza (w tym przypadku naszym kluczem są współrzędne szerokości i długości geograficznej, zaokrąglone w siatkę; przeszukujemy sąsiednie przestrzenie siatki, których jest tylko 9, co jest stałą).
• nasze zadanie poszło z nieosiągalnego O(N²) do łatwego do opanowania O(N), a wszystko, co musieliśmy zrobić, to zapłacić niewielki koszt, aby stworzyć tabelę haszującą.
• analogia : analogia w tym konkretnym przypadku jest układanką: stworzyliśmy strukturę danych, która wykorzystuje pewną własność danych. Jeśli nasze segmenty dróg są jak puzzle, grupujemy je według koloru i wzoru. Następnie wykorzystujemy to, aby uniknąć wykonywania dodatkowej pracy później(porównując kawałki układanki o podobnym kolorze do siebie, a nie do każdego innego pojedynczego elementu układanki).

Morał tej historii: struktura danych pozwala nam przyspieszyć operacje. Nawet bardziej zaawansowane struktury danych pozwalają łączyć, opóźniać lub nawet ignorować operacje w niezwykle sprytny sposób. Różne problemy mają różne analogie, ale wszystkie wiążą się z organizowaniem danych w sposób, który wykorzystuje pewną strukturę, na której nam zależy, lub którą sztucznie narzuciliśmy do prowadzenia ksiąg. Wykonujemy pracę z wyprzedzeniem (w zasadzie planowanie i organizowanie), a teraz powtarzające się zadania są o wiele łatwiejsze!

Praktyczny przykład: wizualizacja porządków wzrostu podczas kodowania

Notacja asymptotyczna jest w swej istocie zupełnie oddzielona od programowania. Asymptotyczne notacja jest ramą matematyczną do myślenia o tym, jak rzeczy skalują się i mogą być używane w wielu różnych dziedzinach. To powiedziane... w ten sposób zastosujesz notację asymptotyczną do kodowania.

Podstawy: gdy wchodzimy w interakcję z każdym elementem w zbiorze wielkości A (takim jak tablica, zbiór, wszystkie klucze mapy itp.), lub wykonać iterację pętli, która jest mnożnikiem wielkości A. dlaczego mówię "mnożnik"?-- ponieważ pętle i funkcje (prawie przez definicja) mają multiplikatywny czas działania: ilość iteracji, czas pracy wykonanej w pętli (lub dla funkcji: ilość razy wywołania funkcji, Czas pracy wykonanej w funkcji). (Obowiązuje, jeśli nie robimy nic wymyślnego, jak pomijanie pętli lub wczesne opuszczanie pętli, lub zmiana przepływu sterowania w funkcji na podstawie argumentów, co jest bardzo powszechne.) Oto kilka przykładów technik wizualizacji, wraz z towarzyszącym im pseudokodem.

(tutaj x reprezentują jednostki pracy w stałym czasie, instrukcje procesora, interpreter opcodes, cokolwiek)

for(i=0; i<A; i++)        // A x ...
    some O(1) operation     // 1

--> A*1 --> O(A) time

visualization:

|<------ A ------->|
1 2 3 4 5 x x ... x

other languages, multiplying orders of growth:
  javascript, O(A) time and space
    someListOfSizeA.map((x,i) => [x,i])               
  python, O(rows*cols) time and space
    [[r*c for c in range(cols)] for r in range(rows)]

Przykład 2:

for every x in listOfSizeA:   // A x ...
    some O(1) operation         // 1
    some O(B) operation         // B
    for every y in listOfSizeC: // C x ...
        some O(1) operation       // 1

--> O(A*(1 + B + C))
    O(A*(B+C))        (1 is dwarfed)

visualization:

|<------ A ------->|
1 x x x x x x ... x

2 x x x x x x ... x ^
3 x x x x x x ... x |
4 x x x x x x ... x |
5 x x x x x x ... x B  <-- A*B
x x x x x x x ... x |
................... |
x x x x x x x ... x v

x x x x x x x ... x ^
x x x x x x x ... x |
x x x x x x x ... x |
x x x x x x x ... x C  <-- A*C
x x x x x x x ... x |
................... |
x x x x x x x ... x v

Przykład 3:

function nSquaredFunction(n) {
    total = 0
    for i in 1..n:        // N x
        for j in 1..n:      // N x
            total += i*k      // 1
    return total
}
// O(n^2)

function nCubedFunction(a) {
    for i in 1..n:                // A x
        print(nSquaredFunction(a))  // A^2
}
// O(a^3)

Jeśli zrobimy coś nieco skomplikowanego, może nadal będziesz w stanie wyobrazić sobie wizualnie, co się dzieje.]}

for x in range(A):
    for y in range(1..x):
        simpleOperation(x*y)

x x x x x x x x x x |
x x x x x x x x x   |
x x x x x x x x     |
x x x x x x x       |
x x x x x x         |
x x x x x           |
x x x x             |
x x x               |
x x                 |
x___________________|

Tutaj liczy się najmniejszy rozpoznawalny kontur, jaki można narysować; trójkąt jest dwuwymiarowym kształtem (0,5 A^2), podobnie jak kwadrat jest dwuwymiarowym kształtem (a^2); współczynnik stały dwóch tutaj pozostaje w stosunku asymptotycznym między nimi, jednak ignorujemy go jak wszystkie czynniki... (Są pewne niefortunne niuanse w tej technice, do których nie Wchodzę; może to wprowadzić cię w błąd.)

Oczywiście nie oznacza to, że pętle i funkcje są złe; wręcz przeciwnie, są one budulcem współczesnych języków programowania i kochamy je. Widzimy jednak, że sposób, w jaki splotamy pętle oraz funkcje i uwarunkowania wraz z naszymi danymi (przepływ sterowania itp.) naśladuje wykorzystanie czasu i przestrzeni naszego programu! Jeśli wykorzystanie czasu i przestrzeni staje się problemem, to wtedy uciekamy się do sprytu i znajdujemy łatwy algorytm lub strukturę danych, o których nie myśleliśmy, aby jakoś zmniejszyć kolejność wzrostu. Niemniej jednak te techniki wizualizacji (choć nie zawsze działają)mogą dać naiwne zgadywanie w najgorszym przypadku.

Oto kolejna rzecz, którą możemy rozpoznać wizualnie:

<----------------------------- N ----------------------------->
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
x x x x x x x x x x x x x x x x
x x x x x x x x
x x x x
x x
x

Możemy po prostu zmienić to i zobaczyć, że to O (N):

<----------------------------- N ----------------------------->
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
x x x x x x x x x x x x x x x x|x x x x x x x x|x x x x|x x|x

A może log(N) przekazuje dane, dla O(N*log (n)) całkowity czas:

   <----------------------------- N ----------------------------->
 ^  x x x x x x x x x x x x x x x x|x x x x x x x x x x x x x x x x
 |  x x x x x x x x|x x x x x x x x|x x x x x x x x|x x x x x x x x
lgN x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x
 |  x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x
 v  x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x

Bez związku, ale warto wspomnieć jeszcze raz: jeśli wykonamy hash (np. wyszukiwanie słownika / hashtable), jest to współczynnik O(1). To dość szybko.

[myDictionary.has(x) for x in listOfSizeA]
 \----- O(1) ------/    

--> A*1 --> O(A)

Jeśli zrobimy coś bardzo skomplikowanego, na przykład z funkcją rekurencyjną lub algorytmem dziel i zdobywaj, możesz użyć twierdzenia mistrza (zwykle działa), lub w śmiesznych przypadkach Twierdzenie Akra-Bazziego (prawie zawsze działa) sprawdzasz czas działania algorytmu na Wikipedii.

Ale programiści nie myślą w ten sposób, ponieważ w końcu intuicja algorytmu staje się drugą naturą. Zaczniesz kodować coś nieefektywnego i natychmiast pomyślisz :" czy robię coś rażąco nieefektywnego?". Jeśli odpowiedź brzmi "tak" i przewidujesz, że ma to znaczenie, możesz cofnąć się o krok i pomyśleć o różnych sztuczkach, aby wszystko działało szybciej (odpowiedź brzmi prawie zawsze "użyj hashtable", rzadko "użyj drzewa" , a bardzo rzadko coś nieco bardziej skomplikowanego).

Zamortyzowana i średnia złożoność sprawy

Istnieje również pojęcie " amortyzowanego "i/lub" przeciętnego przypadku " (zauważ, że są one różne).

Średni przypadek: nie jest to nic więcej niż użycie notacji big-O dla wartości oczekiwanej funkcji, a nie samej funkcji. W zwykłym przypadku, gdy uznać wszystkie dane wejściowe za równie prawdopodobne, Przeciętny przypadek jest tylko średnią czasu pracy. Na przykład w przypadku quicksort, nawet jeśli najgorszy przypadek to O(N^2) dla niektórych naprawdę złych wejść, średnia wielkość to zwykle O(N log(N)) (naprawdę złe wejścia są bardzo małe, tak mało, że nie zauważamy ich w przeciętnym przypadku).

Amortyzowany najgorszy przypadek: niektóre struktury danych mogą mieć złożoność najgorszego przypadku, która jest duża, ale gwarantują, że jeśli wykonasz wiele z tych operacje, średnia ilość pracy, którą wykonujesz, będzie lepsza niż w najgorszym przypadku. Na przykład możesz mieć strukturę danych, która zwykle zajmuje stały czas O(1). Jednak czasami Będzie to "czkawka" i zajmie {40]} czas na jedną przypadkową operację, ponieważ może trzeba zrobić jakąś księgowość lub wywóz śmieci lub coś takiego... ale obiecuje ci, że jeśli to zrobi czkawkę, to nie będzie czkawka ponownie Dla N więcej operacji. W najgorszym przypadku koszt jest nadal O(N) na operację, ale zamortyzowany koszt przez wiele przebiegów jest O(N)/N = O(1) na operację. Ponieważ duże operacje są wystarczająco rzadkie, ogromna ilość okazjonalnej pracy można uznać za mieszanie się z resztą pracy jako stały czynnik. Mówimy, że utwór jest "amortyzowany" przez wystarczająco dużą liczbę połączeń, że znika asymptotycznie.

Analogia do analizy amortyzacyjnej:

Prowadzisz samochód. Czasami trzeba spędzić 10 minut idąc do Gaz stacji, a następnie spędzić 1 minutę napełniania zbiornika gazem. Jeśli robiłeś to za każdym razem, gdy jeździłeś gdziekolwiek samochodem (wydaj 10 minut jazdy do stacji benzynowej, spędzić kilka sekund napełniania ułamek galonu), byłoby to bardzo nieefektywne. Ale jeśli wypełnisz w górę zbiornika raz na kilka dni, 11 minut spędzonych jazdy do Stacja benzynowa jest "zamortyzowana" przez wystarczająco dużą liczbę przejazdów, że możesz to zignorować i udawać, że wszystkie twoje wycieczki były Może 5% dłużej.

Porównanie przeciętnego przypadku i amortyzowanego najgorszego przypadku:

• Average-case: przyjmujemy pewne założenia dotyczące naszych wejść; tzn. jeśli nasze wejścia mają różne prawdopodobieństwa,to nasze wyjścia / czasy uruchomień będą miały różne prawdopodobieństwa(które przyjmujemy średnią). Zazwyczaj Zakładamy, że wszystkie nasze wejścia są jednakowo prawdopodobne( jednorodne prawdopodobieństwo), ale jeśli rzeczywiste wejścia nie pasują do naszych założeń "średniego wejścia", średnia wydajność / czas pracy obliczenia mogą być bez znaczenia. Jeśli jednak przewidujesz jednolicie losowe wejścia, warto o tym pomyśleć!
• amortyzowany najgorszy przypadek: jeśli korzystasz z amortyzowanej struktury danych najgorszego przypadku, wydajność jest gwarantowana, aby mieścić się w amortyzowanym najgorszym przypadku... ostatecznie (nawet jeśli wejścia są wybierane przez złego demona, który wie wszystko i próbuje cię wyrolować). Zwykle używamy tego do analizy algorytmów, które mogą być bardzo "niepewne" w wydajności z nieoczekiwanych dużych czkawki, ale z czasem działają tak samo dobrze jak inne algorytmy. (Jednak o ile twoja struktura danych nie ma górnych limitów dla wielu wybitnych prac, które jest gotów zwlekać, zły napastnik może być zmuszony do nadrobienia maksymalnej ilości zwlekanej pracy na raz.

Chociaż, jeśli jesteś rozsądnie zaniepokojony atakującym, istnieje wiele innych algorytmicznych wektorów ataku martwić się o oprócz amortyzacji i Przeciętny przypadek.)

Zarówno średni przypadek, jak i amortyzacja są niezwykle przydatnymi narzędziami do myślenia i projektowania z myślą o skalowaniu.

(Patrz różnica między przeciętnym przypadkiem a analizą amortyzowaną jeśli interesuje Cię ta Podkategoria.)

Wielowymiarowy big-o

Cała historia

Pamiętaj, że big-O to nie cała historia. Można drastycznie przyspieszyć niektóre algorytmy za pomocą buforowania, czyniąc je nieświadomymi pamięci podręcznej, unikając wąskich gardeł, pracując z pamięcią RAM zamiast dysku, używaniem paralelizacji lub wykonywaniem pracy z wyprzedzeniem -- te techniki są często niezależne od notacji "big-O", chociaż często można zobaczyć liczbę rdzeni w notacji big-O algorytmów równoległych.

Pamiętaj również, że ze względu na Ukryte ograniczenia Twojego programu, możesz nie dbać o asymptotyczne zachowanie. Możesz pracować z ograniczoną liczbą wartości, na przykład:

• jeśli jesteś sortowanie czegoś takiego jak 5 elementów, nie chcesz używać szybkiego O(N log(N)) quicksort; chcesz użyć sortowania wstawiania, co zdarza się dobrze działać na małych wejściach. Takie sytuacje często pojawiają się w algorytmach divide-and-conquer, gdzie dzielimy problem na mniejsze i mniejsze podproblemy, takie jak sortowanie rekurencyjne, szybkie transformaty Fouriera lub mnożenie macierzy.
• jeśli pewne wartości są skutecznie ograniczone z powodu jakiegoś ukrytego faktu (np. przeciętne ludzkie imię jest łagodnie Ograniczony na około 40 liter, a wiek człowieka jest łagodnie Ograniczony na około 150). Możesz również nałożyć ograniczenia na dane wejściowe, aby skutecznie uczynić warunki stałymi.

Programy będą działać wolniej na komputerze 500MHz vs 2GHz. Nie uważamy tego za część ograniczeń zasobów, ponieważ myślimy o skalowaniu w kategoriach zasobów maszynowych (np. na cykl zegara), a nie na realną sekundę. Są jednak podobne rzeczy, które mogą "potajemnie" wpływać na wydajność, takie jak to, czy używasz emulacji, czy kompilator zoptymalizowany kod czy nie. Może to sprawić, że niektóre podstawowe operacje będą trwać dłużej (nawet względem siebie), a nawet przyspieszyć lub spowolnić niektóre operacje asymptotycznie(nawet względem siebie). Efekt może być mały lub duży między różnymi implementacjami i / lub środowiskiem. Czy zmieniasz języki lub maszyny, aby wykonać tę dodatkową pracę? To zależy od stu innych powodów (konieczność, umiejętności, współpracownicy, produktywność programisty, wartość pieniężna twojego czasu, znajomość, obejścia, dlaczego nie assembly lub GPU, itp...), co może być ważniejsze od osiągów.

Powyższe zagadnienia, jak język programowania, prawie nigdy nie są uważane za część stałego czynnika (ani nie powinny być); jednak należy mieć ich świadomość, ponieważ czasami (choć rzadko) mogą mieć wpływ na rzeczy. Na przykład w cpython, natywna implementacja kolejki priorytetów jest asymptotycznie nieoptymalna (O(log(N)) zamiast O(1) do wyboru wstawiania lub find-min); Czy używasz innej implementacji? Prawdopodobnie nie, ponieważ implementacja C jest prawdopodobnie szybsza i prawdopodobnie są inne podobne problemy gdzie indziej. Są pewne kompromisy; czasami mają znaczenie, a czasami nie.]}

(edit : Wyjaśnienie" plain English " kończy się tutaj.)

dodatek matematyczny

Dla kompletności dokładna definicja notacji big-O jest następująca: f(x) ∈ O(g(x)) oznacza, że " f jest asymptotycznie upper-bounded by const * g": ignorując wszystko poniżej pewnej skończonej wartości x, istnieje stała taka, że |f(x)| ≤ const * |g(x)|. (Pozostałe symbole są następujące: podobnie jak O oznacza≤, Ω oznacza ≥. Istnieją warianty pisane małymi literami: o oznacza ω oznacza >.) f(x) ∈ Ɵ(g(x)) oznacza zarówno f(x) ∈ O(g(x)), jak i f(x) ∈ Ω(g(x)) (górna i dolna granica g): istnieją pewne stałe takie, że f zawsze będzie leżeć w "paśmie" pomiędzy const1*g(x) i const2*g(x). Jest to najsilniejsze stwierdzenie asymptotyczne, jakie można wykonać i mniej więcej odpowiednik ==. (Przepraszam, zdecydowałem się opóźnić wzmiankę o symbolach wartości absolutnej aż do teraz, dla jasności; zwłaszcza, że nigdy nie widziałem negatywnych wartości pojawiają się w kontekście informatyki.)

Ludzie często używają = O(...), co jest być może bardziej poprawną notacją "comp-sci" i całkowicie uzasadnioną do używania... należy jednak zdawać sobie sprawę, że = nie jest używany jako równość; jest to zapis złożony, który należy odczytywać jako idiom. Nauczono mnie używać bardziej rygorystyczne ∈ O(...). ∈ oznacza "jest elementem". O(N²) jest w rzeczywistości klasą równoważności , czyli jest zbiorem rzeczy, które uważamy za takie same. W tym konkretnym przypadku O(N²) zawiera takie elementy jak {2 N², 3 N², 1/2 N², 2 N² + log(N), - N² + N^1.9, ... i jest nieskończenie duża, ale to wciąż zbiór. Notacja = może być bardziej powszechna i jest nawet używana w dokumentach przez światowej sławy informatyków. Dodatkowo często zdarza się, że w przypadkowym jest to technicznie prawdziwe, ponieważ zbiór rzeczy Ɵ(exactlyThis) jest podzbiorem O(noGreaterThanThis)... i łatwiej pisać. ;-)

EDIT: szybka uwaga, to jest prawie na pewno mylące notacja Big O (która jest górną granicą) z notacją Theta (która jest zarówno górną, jak i dolną granicą). Z mojego doświadczenia wynika, że jest to typowe dla dyskusji w środowiskach pozaakademickich. Przepraszam za zamieszanie.

Jednym zdaniem: ile czasu zajmie ukończenie pracy?

Oczywiście, że tylko "rozmiar" jako wejście i "czas wzięty" jako wyjście - to samo pomysł dotyczy, jeśli chcesz porozmawiać o zużyciu pamięci itp.

Oto przykład, w którym mamy N T-shirty, które chcemy wysuszyć. Przyjmiemy, że jest to niezwykle szybkie, aby umieścić je w pozycji suszenia (tzn. interakcja człowieka jest znikoma). Oczywiście w prawdziwym życiu tak nie jest...

• Korzystanie z linii myjącej Na Zewnątrz: zakładając, że masz nieskończenie duże podwórko, pranie wysycha w czasie O (1). Bez względu na to, ile masz, będzie to samo słońce i świeże powietrza, więc rozmiar nie wpływa na czas schnięcia.

• Za pomocą suszarki bębnowej: wkładasz 10 koszulek do każdego ładunku, a następnie kończysz godzinę później. (Zignoruj rzeczywiste liczby tutaj-są nieistotne.) Więc suszenie 50 koszul zajmuje około 5 razy dłużej niż suszenie 10 koszul.

• Wkładanie wszystkiego do wietrznej szafki: jeśli umieścimy wszystko w jednym dużym stosie i po prostu pozwolimy, aby ogólne ciepło to zrobiło, to zajmie dużo czasu, zanim środkowe koszule wyschną. I nie chciałbym zgadywać szczegółów, ale podejrzewam, że jest to co najmniej O (N^2) - wraz ze zwiększeniem obciążenia mycia, czas schnięcia wzrasta szybciej.

Jednym z ważnych aspektów notacji" big O" jest to, że nie mówi, który algorytm będzie szybszy dla danego rozmiaru. Weź hashtable (string key, integer value) vs tablicę par (string, integer). Czy szybciej jest znaleźć klucz w hashtable lub element w tablicy, oparty na łańcuchu znaków? (tj. dla tablicy " znajdź pierwszy element, w którym część ciągu odpowiada podanemu kluczowi.") Hashtables są na ogół amortyzowane (~="średnio") O (1 ) - po ich skonfigurowaniu znalezienie wpisu w tabeli wpisów 100 powinno zająć mniej więcej ten sam czas, co w tabeli wpisów 1,000,000. Znalezienie elementu w tablicy (na podstawie zawartości, a nie indeksu) jest liniowe, tzn. O (N) - średnio będziesz musiał spojrzeć na połowę wpisów.

Czy to sprawia, że hashtable jest szybsze niż tablica do wyszukiwania? Niekoniecznie. Jeśli masz masz bardzo mały zbiór wpisów, tablica może być szybsza - możesz być w stanie sprawdzić wszystkie ciągi w czasie, który zajmuje, aby po prostu obliczyć hashcode tego, na który patrzysz. W miarę powiększania się zbioru danych, tablica hashtable ostatecznie przebije tablicę.

Big O opisuje górną granicę wzrostu funkcji, na przykład czasu pracy programu, gdy dane wejściowe stają się duże.

Przykłady:

• O (n): jeśli podwoję rozmiar wejścia, runtime podwaja

• O (n²): Jeśli rozmiar wejściowy podwaja czterokrotnie runtime

• O (log n): Jeśli rozmiar wejściowy podwaja runtime zwiększa się o jeden

• O (2 ^N): Jeśli rozmiar wejściowy zwiększy się o jeden, runtime double

Rozmiar wejściowy jest zwykle spacją w bitach potrzebną do reprezentowania wejścia.

Notacja Big O jest najczęściej używana przez programistów jako przybliżona miara czasu wykonania obliczeń (algorytmu) wyrażona jako funkcja wielkości zestawu wejściowego.

Duże O jest przydatne do porównania, jak dobrze dwa algorytmy będą skalowane w miarę zwiększania liczby wejść.

Dokładniej notacja Big O jest używana do wyrażania asymptotycznego zachowania funkcji. Oznacza to, jak funkcja zachowuje się, gdy zbliża się do nieskończoności.

W wielu przypadkach "O" algorytmu spadnie do jednego z następujących przypadków:

• O (1) - Czas zakończenia jest taki sam niezależnie od wielkości zestawu wejściowego. Przykładem jest dostęp do elementu tablicy za pomocą indeksu.
• O (Log N) - Czas do zakończenia zwiększa się mniej więcej zgodnie z log2 (n). Na przykład 1024 pozycji zajmuje mniej więcej dwa razy więcej niż 32 Pozycje, ponieważ Log2(1024) = 10 i Log2(32) = 5. Przykładem jest znalezienie przedmiotu w binarne drzewo wyszukiwania (BST).
• O (N) - Czas zakończenia skalowania liniowo z rozmiarem zestawu wejściowego. Innymi słowy, jeśli podwoisz liczbę elementów w zestawie wejściowym, algorytm zajmie mniej więcej dwa razy więcej czasu. Przykładem jest zliczanie liczby pozycji na połączonej liście.
• O (N Log N) - Czas zakończenia zwiększa się o liczbę pozycji razy wynik Log2(N). Przykładem tego jest sortowanie sterty i szybkie sortowanie .
• O (N^2) - Czas zakończenia jest w przybliżeniu równy Kwadratowi liczby elementów. Przykładem tego jest sortowanie bąbelków.
• O (N!) - Czas do zakończenia jest czynnikiem zestawu wejściowego. Przykładem tego jest problem komiwojażera rozwiązanie brute-force .

Big O ignoruje czynniki, które nie przyczyniają się w znaczący sposób do krzywej wzrostu funkcji, ponieważ wielkość wejściowa wzrasta w kierunku nieskończoności. To oznacza, że stałe dodawane do funkcji lub mnożone przez nią są po prostu ignorowane.

Big O to tylko sposób na" wyrażenie "siebie w zwykły sposób," ile czasu / przestrzeni zajmuje uruchomienie mojego kodu?".

Możesz często zobaczyć O (n), O (n²), O (nlogn) i tak dalej, wszystko to są tylko sposoby na pokazanie; jak zmienia się algorytm?

O (n) oznacza Duże O to n, A teraz możesz pomyśleć: "co to jest n!?"No" n " to ilość pierwiastków. Obrazowanie chcesz wyszukać element w tablicy. Trzeba by spojrzeć na każdy element i jako "Czy jesteś poprawny element/element?"w najgorszym przypadku Pozycja znajduje się na ostatnim indeksie, co oznacza, że zajęło to tyle czasu, ile są pozycje na liście, więc aby być ogólnym, mówimy "oh hey, n to uczciwa ilość wartości!".

Więc może zrozumiesz co " n²" oznacza, ale żeby być jeszcze bardziej szczegółowym, baw się z myślą, że masz prosty, najprostszy z algorytmów sortowania; bubblesort. Algorytm ten musi przejrzeć całą listę dla każdego elementu.

My lista

1. 1
2. 6
3. 3

Przepływ tutaj będzie:

• Porównaj 1 i 6, która jest największa? Ok 6 jest we właściwej pozycji, idzie do przodu!
• Porównaj 6 i 3, OH, 3 to mniej! Przenieśmy to, Ok Lista się zmieniła, musimy zacząć od początku teraz!

To Jest O n² ponieważ, trzeba spojrzeć na wszystkie elementy na liście są " n " elementów. Dla każdego elementu, spojrzysz na wszystkie elementy jeszcze raz, aby porównać, jest to również "n", więc dla każdego elementu wyglądamy " N " razy oznaczając n*n = n²

Mam nadzieję, że to jest tak proste, jak chcesz.

Ale pamiętaj, Big O to tylko sposób, aby doświadczyć siebie w sposób czasu i przestrzeni.

Big O opisuje fundamentalną naturę skalowania algorytmu.

Istnieje wiele informacji, których Big O nie mówi o danym algorytmie. Tnie do kości i daje tylko informacje o skalowaniu charakteru algorytmu, w szczególności jak wykorzystanie zasobów (czas lub pamięć) algorytmu skaluje się w odpowiedzi na"rozmiar wejścia".

Rozważ różnicę między silnikiem parowym a rakietą. Nie są to jedynie różne odmiany to samo (jak np. silnik Priusa vs. Silnik Lamborghini), ale są to diametralnie różne rodzaje układów napędowych, w ich rdzeniu. Silnik parowy może być szybszy niż rakieta-zabawka, ale żaden parowy silnik tłokowy nie będzie w stanie osiągnąć prędkości orbitalnego pojazdu startowego. Dzieje się tak, ponieważ systemy te mają różne właściwości skalowania w odniesieniu do stosunku paliwa wymaganego ("zużycie zasobów") do osiągnięcia danej prędkości ("wielkość wejścia").

Dlaczego to takie ważne? Ponieważ oprogramowanie radzi sobie z problemami, które mogą różnić się wielkością o Czynniki do biliona. Zastanów się przez chwilę. Stosunek prędkości niezbędnej do podróży na Księżyc i prędkości chodzenia człowieka jest mniejszy niż 10 000:1, A to jest absolutnie małe w porównaniu do zakresu wielkości wejściowych, z którymi może się zmierzyć oprogramowanie. A ponieważ oprogramowanie może napotkać astronomiczny zakres wielkości wejściowych, istnieje potencjał dużej złożoności algorytmu, jest to fundamentalna natura skalowania, aby pokonać wszelkie szczegóły realizacji.

Rozważmy kanoniczny przykład sortowania. Bubble-sort to O (n²) podczas gdy merge-sort to O (N log n). Załóżmy, że masz dwie sortujące aplikacje, aplikację A, która używa sortowania bąbelkowego i aplikację B, która używa sortowania scalającego, i załóżmy, że dla wielkości wejściowych około 30 elementów aplikacja a jest 1000 x szybsza niż aplikacja B przy sortowaniu. Jeśli nigdy nie musisz sortować znacznie więcej niż 30 elementów, to oczywiste jest, że powinieneś preferować aplikację A, ponieważ jest znacznie szybszy przy tych rozmiarach wejściowych. Jednak, jeśli okaże się, że może trzeba posortować dziesięć milionów elementów to czego można się spodziewać jest to, że aplikacja B faktycznie kończy się tysiące razy szybciej niż aplikacja A w tym przypadku, całkowicie ze względu na sposób każdy algorytm skaluje.

Oto prosty angielski bestiariusz, którego zwykle używam, wyjaśniając popularne odmiany Big-O

We wszystkich przypadkach preferuj algorytmy wyżej na liście niż te niżej na liście. Jednak koszt przejścia do droższej klasy złożoności znacznie się różni.

O(1):

Brak wzrostu. Niezależnie od tego, jak duży jest problem, możesz go rozwiązać w tym samym czasie. Jest to nieco analogiczne do nadawania, gdzie zajmuje taką samą ilość energii do transmisji na danym dystansie, niezależnie od liczby osób, które znajdują się w zasięgu transmisji.

O (log n):

Ta złożoność jest taka sama jak O(1) z tym, że jest tylko trochę gorzej. Dla wszystkich praktycznych celów można to uznać za bardzo duże ciągłe skalowanie. Różnica w pracy między przetwarzaniem 1 tys. A 1 mld pozycji jest tylko czynnikiem szóstym.

O (n):

Koszt rozwiązania problemu jest proporcjonalna do wielkości problemu. Jeśli twój problem podwaja rozmiar, koszt rozwiązania podwaja się. Ponieważ większość problemów musi być skanowana do komputera w jakiś sposób, jak wprowadzanie danych, odczyt dysku lub ruch sieciowy, jest to ogólnie przystępny współczynnik skalowania.

O (n log n):

Ta złożoność jest bardzo podobna do O (n). Dla wszystkich praktycznych celów, te dwa są równoważne. To poziom złożoności byłby ogólnie nadal uważany za skalowalny. Poprawiając założenia niektóre O (n log n) algorytmy można przekształcić w O (n) algorytmy. Na przykład ograniczenie rozmiaru kluczy zmniejsza sortowanie z O ( n log n) do O (n).

O (n²):

Rośnie jako kwadrat, gdzie n jest długością boku kwadratu. To to takie samo tempo wzrostu jak "efekt sieci", gdzie wszyscy w sieci mogą znać wszystkich innych w sieci. Wzrost jest drogi. Większość skalowalnych rozwiązań nie może używać algorytmów o takim poziomie złożoności bez wykonywania znacznej gimnastyki. Dotyczy to ogólnie wszystkich innych kompleksów wielomianowych - O (n^k) - też.

O(2ⁿ):

Nie skaluje się. Nie masz nadziei na rozwiązanie żadnego Nie-trywialnego problem z rozmiarem. Przydatne do wiedzy, czego unikać, i dla ekspertów, aby znaleźć przybliżone algorytmy, które są w O (n^k).

Duże O jest miarą czasu / przestrzeni, jaką wykorzystuje algorytm w stosunku do wielkości jego wejścia.

Jeśli algorytm jest O(n), to czas / przestrzeń będzie wzrastać z taką samą szybkością jak jego wejście.

Jeśli algorytm jest O (n²) Następnie czas / przestrzeń wzrasta z szybkością jego wejścia do kwadratu.

I tak dalej.

Bardzo trudno jest zmierzyć prędkość oprogramowania, a kiedy próbujemy, odpowiedzi mogą być bardzo złożone i wypełnione wyjątkami i szczególnymi przypadkami. Jest to duży problem, ponieważ wszystkie te wyjątki i przypadki specjalne rozpraszają uwagę i są nieprzydatne, gdy chcemy porównać dwa różne programy ze sobą, aby dowiedzieć się, który jest "najszybszy".

W wyniku całej tej nieprzydatnej złożoności, ludzie starają się opisać szybkość oprogramowania za pomocą najmniejszych i możliwie najmniej złożone (matematyczne) wyrażenia. Wyrażenia te są bardzo prymitywnymi przybliżeniami: chociaż przy odrobinie szczęścia uchwycą "istotę" tego, czy oprogramowanie jest szybkie, czy wolne.

Ponieważ są to przybliżenia, używamy litery " O " (Big Oh) w wyrażeniu, jako konwencji, aby zasygnalizować czytelnikowi, że robimy rażące uproszczenie. (I upewnić się, że nikt nie pomyśli, że wyrażenie jest w jakikolwiek sposób dokładne).

Jeśli odczytasz " Oh "jako" w kolejności "lub" w przybliżeniu", nie pomylisz się zbyt daleko. (Myślę, że wybór Big-Oh mógł być próbą humoru).

Jedyną rzeczą, którą te wyrażenia "Big-Oh" próbują zrobić, jest opisanie, jak bardzo oprogramowanie zwalnia, gdy zwiększamy ilość danych, które oprogramowanie musi przetworzyć. Jeśli podwoimy ilość danych, które muszą być przetwarzane, czy oprogramowanie potrzebuje dwa razy więcej czasu, aby zakończyć swoją pracę? Dziesięć razy dłużej? W praktyce istnieje bardzo ograniczona liczba wyrażeń big-Oh, które napotkasz i musisz się martwić: {]}

Dobry:

• O(1) Constant : program uruchamia się w tym samym czasie, bez względu na to, jak duże jest wejście.
• O(log n) logarytmiczny: Czas pracy programu wzrasta tylko powoli, nawet przy dużym wzroście wielkości wejścia.

Zły:

• O(n) Linear : program czas wykonania zwiększa się proporcjonalnie do wielkości wejścia.
• O(n^k) wielomian: - Czas Przetwarzania rośnie szybciej i szybciej-jako funkcja wielomianowa - wraz ze wzrostem wielkości wejścia.

... i brzydkie:

• O(k^n) wykładniczy Czas pracy programu wzrasta bardzo szybko, nawet umiarkowany wzrost wielkości problemu - praktyczne jest tylko przetwarzanie małych zbiorów danych za pomocą algorytmów wykładniczych.
• O(n!) Factorial Czas działania programu będzie dłuższy niż możesz sobie pozwolić na czekanie na cokolwiek innego niż najmniejsze i najbardziej trywialne zbiory danych.

Jakie jest proste angielskie Wyjaśnienie Big O? Z jak najmniejszą formalną definicją i prostą matematyką.

Proste angielskie Wyjaśnienie Need dla notacji Big-O:

Proste angielskie Wyjaśnienie czym jest notacja Big O:

Nie wszystkie algorytmy działają w tym samym czasie i mogą się różnić w zależności od liczby pozycji na wejściu, które nazwiemy n . Na tej podstawie rozważamy gorszą analizę przypadku, lub górną granicę czasu wykonania, ponieważ n stają się coraz większe. Musimy być świadomi tego, czym jest n, ponieważ wiele dużych notacji O odwołuje się do tego.

Prosta odpowiedź może brzmieć:

Big O reprezentuje najgorszy możliwy czas / przestrzeń dla tego algorytmu. Algorytm nigdy nie zajmie więcej przestrzeni / czasu powyżej tej granicy. Duże O reprezentuje złożoność czas / przestrzeń w skrajnym przypadku.

Ok, moje 2cents.

Big-O, jest szybkością zwiększania zasobów zużytych przez program, w. r. t. problem-instancja-Rozmiar

Zasób: może być całkowity czas procesora, może być maksymalna ilość pamięci RAM. Domyślnie odnosi się do czasu procesora.

Powiedz, że problemem jest "znajdź sumę",

int Sum(int*arr,int size){
      int sum=0;
      while(size-->0) 
         sum+=arr[size]; 

      return sum;
}

Problem-instancja= {5,10,15} = = > problem-instancja-Rozmiar= 3, iteracje-w-pętli= 3

Problem-instancja= {5,10,15,20,25} = = > problem-instancja-rozmiar = 5 iteracji-w-pętli = 5

Dla wejście rozmiaru " n "program rośnie z prędkością" n " iteracji w tablicy. Stąd Duże-O jest N wyrażone jako O (n)

Powiedz, że problemem jest "znajdź kombinację",

    void Combination(int*arr,int size)
    { int outer=size,inner=size;
      while(outer -->0) {
        inner=size;
        while(inner -->0)
          cout<<arr[outer]<<"-"<<arr[inner]<<endl;
      }
    }

Problem-instancja= {5,10,15} = = > problem-instancja-Rozmiar = 3, suma-iteracji = 3*3 = 9

Problem-instancja= {5,10,15,20,25} = = > problem-instancja-rozmiar = 5, suma-iteracji = 5*5 =25

Dla danych wejściowych o rozmiarze " n "program rośnie z prędkością iteracji" n*n " w tablicy. Stąd Big-O jest N² wyrażona jako O (n²)

Notacja Big O jest sposobem opisania górnej granicy algorytmu pod względem przestrzeni lub czasu działania. N to liczba elementów w problemie (np. rozmiar tablicy, Liczba węzłów w drzewie, itd.) Jesteśmy zainteresowani opisaniem czasu pracy, gdy n staje się duże.

Kiedy mówimy, że jakiś algorytm jest O (f (n)), mówimy, że czas działania (lub przestrzeń wymagana) przez ten algorytm jest zawsze niższy niż jakieś stałe czasy f(n).

Powiedzieć, że wyszukiwanie binarne ma czas działania o (logn) oznacza, że istnieje stała c, którą można pomnożyć przez log (n), która zawsze będzie większa niż czas działania wyszukiwania binarnego. W takim przypadku zawsze będziesz mieć jakiś stały współczynnik porównań log(n).

Innymi słowy, gdzie g (n) jest czasem działania algorytmu, mówimy, że g(n) = O(f(n)), gdy g(n) k, gdzie c i k są stałymi.

"Co to jest proste angielskie Wyjaśnienie Big O? Z jak najmniejszym formalnym definicja jak to możliwe i prosta matematyka."

Tak pięknie proste i krótkie pytanie wydaje się przynajmniej zasługiwać na równie krótką odpowiedź, jak uczeń może otrzymać podczas korepetycji.

Notacja Big O po prostu mówi, ile czasu * algorytm może działać w, w kategoriach tylko ilość danych wejściowych **.

( *w cudownym, bez jednostek poczucie czasu!)
(**co się liczy, bo ludzie będą Zawsze chcę więcej , czy żyją dziś czy jutro)

• Praktycznie rzecz biorąc, analiza Big O jest tak przydatna i ważna , ponieważ Big O skupia się na złożoności algorytmu i całkowicie ignoruje wszystko, co jest tylko stała proporcjonalności - jak silnik JavaScript, prędkość procesora, połączenie z Internetem i wszystkie te rzeczy, które szybko stają się śmiesznie przestarzałe jak Model T . Big O skupia się na wydajności tylko w taki sposób, który ma równie duże znaczenie dla ludzi żyjących w teraźniejszości lub w przyszłości.

• Notacja Big O zwraca również uwagę bezpośrednio na najważniejszą zasadę programowania/inżynierii komputerowej, która inspiruje wszystkie dobre Programiści, aby myśleć i marzyć: jedynym sposobem osiągnięcia wyników poza powolnym postępem technologii jest wymyślenie lepszego algorytmu .

Przykład algorytmu (Java):

// given a list of integers L, and an integer K
public boolean simple_search(List<Integer> L, Integer K)
{
    // for each integer i in list L
    for (Integer i : L)
    {
        // if i is equal to K
        if (i == K)
        {
            return true;
        }
    }

    return false;
}

Opis algorytmu:

• Algorytm ten przeszukuje listę, pozycja po pozycji, szukając klucza,

• Iteracja na każdej pozycji na liście, jeśli jest to klucz, to return True,

• Jeśli pętla została zakończona bez znalezienia klucza, zwraca False.

notacja Big-O przedstawia górną granicę złożoności (czas, przestrzeń, ..)

Aby znaleźć Big-O na czas złożoność:

• Oblicz, ile czasu (jeśli chodzi o wielkość wejściową) zajmuje najgorszy przypadek:

• Najgorszy przypadek: klucz nie istnieje na liście.

• Czas (najgorszy przypadek) = 4n+1

• Czas: O(4n+1) = O (n) | w Big-O, stałe są zaniedbywane

• O (n) ~ Linear

Istnieje również Big-Omega, które reprezentują złożoność najlepszego przypadku:

• Best-Case: the key jest pierwszym elementem.

• Czas (Best-Case) = 4

• Czas: Ω(4) = O(1) ~ Instant\Constant

Big O

f (x) = O (g (x)) gdy x przechodzi do a (na przykład a = +∞) oznacza, że istnieje funkcja k taka, że:

1. f (x) = k (x) g (x)

2. K jest ograniczone w pewnym sąsiedztwie a (jeśli a=+∞, oznacza to, że istnieją liczby N I M takie, że dla każdego x > N, / k (x)|

Innymi słowy, po angielsku: f (x) = O ( g (x)), x → a, oznacza, że w sąsiedztwie a, f rozkłada się na iloczyn g i pewną ograniczoną funkcję.

Małe o

Przy okazji, oto dla porównania definicja małego o.

f (x) = o (g (x)) gdy x przechodzi do A oznacza, że istnieje funkcja k taka, że:

1. f (x) = k (x) g (x)

2. k (x) przechodzi do 0, gdy x przechodzi do a.

przykłady

• Sin x = O(X), gdy x → 0.

• Sin x = O (1) Gdy x → +∞,

• X² + x = O(X) gdy x → 0,

• X² + x = O (x²) gdy x → +∞,

• Ln(x) = o(x) = O (X) gdy x → +∞.

Uwaga! zapis ze znakiem równości " = "używa" fałszywej równości": prawdą jest, że o (g (x)) = O (G (x)), ale fałszywe, że O(g (x)) = o (g (x)). Podobnie można napisać " ln(x) = O(X) gdy X → +∞", ale formuła "o(x) = ln (x)" nie ma sensu.

więcej przykładów

• O (1) = O (n) = O (n²) gdy n → + ∞ (ale nie odwrotnie, równość jest "fałszywa"),

• O (n) + O (n²) = O (n²) kiedy n → +∞

• O (O (n²)) = O (n²) kiedy n → +∞

• O (n²)O (n³) = O (n⁵) kiedy n → +∞

Oto artykuł w Wikipedii: https://en.wikipedia.org/wiki/Big_O_notation

Duża notacja O jest sposobem opisania jak szybko algorytm będzie działał z dowolną liczbą parametrów wejściowych, które nazwiemy "n". Jest to przydatne w informatyce, ponieważ różne maszyny działają z różnymi prędkościami, a samo powiedzenie, że algorytm zajmuje 5 sekund, nie mówi wiele, ponieważ podczas gdy możesz uruchomić system z ośmiordzeniowym procesorem 4,5 Ghz, ja mogę uruchomić 15-letni, 800 Mhz system, który może trwać dłużej, niezależnie od algorytmu. Więc zamiast określać, jak szybko algorytm działa pod względem czasu, mówimy, jak szybko działa pod względem liczby parametrów wejściowych, Czyli "n". Opisując algorytmy w ten sposób, jesteśmy w stanie porównać prędkości algorytmów bez konieczności uwzględniania prędkości samego komputera.

Nie jestem pewien, czy dalej przyczyniam się do tematu, ale nadal myślałem, że podzielę się: kiedyś znalazłem Ten post na blogu , aby mieć kilka bardzo pomocnych (choć bardzo podstawowych) wyjaśnień i przykładów na Big O:

Poprzez przykłady, to pomogło dostać gołe podstawy do mojej czaszki tortoiseshell-like, więc myślę, że to dość zejście 10-minutowe czytanie, aby dostać się w dobrym kierunku.

Chcesz wiedzieć wszystko o big O? Ja też.

Więc mówiąc o big O, użyję słów, które mają tylko jeden rytm w nich. Jeden dźwięk na słowo. Małe słowa są szybkie. Znasz te słowa, tak jak ja. użyjemy słów jednym dźwiękiem. Są małe. Jestem pewien, że znasz wszystkie słowa, których użyjemy!

Nie lubię chodzić do pracy. Nie lubię spędzać czasu w pracy. Gdybym miał swój sposób, chciałbym po prostu grać i robić zabawne rzeczy. Czujesz to samo co ja?

Teraz czasami muszę iść do pracy. To smutne, ale prawdziwe. Tak więc, kiedy jestem w pracy, mam zasadę: staram się wykonywać mniej pracy. Tak blisko żadnej pracy, jak tylko mogę. Potem idę się pobawić!

Oto wielka wiadomość: wielkie O może pomóc mi nie wykonywać pracy! Mogę grać częściej, jeśli znam big O. mniej pracy, więcej Graj! To właśnie pomaga mi big O.

Teraz mam trochę pracy. Mam listę: 1, 2, 3, 4, 5, 6. Muszę dodać wszystkie rzeczy do tej listy.

Wow, nienawidzę pracy. Ale cóż, muszę to zrobić. No to lecę.

Jeden plus dwa to trzy ... plus trzy to sześć... i cztery... Nie wiem. Zgubiłem się. To jest zbyt trudne dla mnie zrobić w mojej głowie. Nie dbam o tego rodzaju pracę.

Więc nie róbmy tego. Zastanówmy się, jak ciężko jest. Ile pracy musiałbym zrobić, żeby dodać sześć cyfr?

Cóż, zobaczmy. Muszę dodać jeden i dwa, a potem dodać to do trzech, a potem dodać to do czterech... w sumie naliczyłem sześć dodań. Muszę zrobić sześć dodatków, żeby to rozwiązać.

Nadchodzi wielki O, aby powiedzieć nam, jak trudna jest ta matematyka.

Big O mówi: Musimy zrobić sześć dodatków, aby rozwiązać ten problem. Jeden dodatek, za każdą rzecz od jednego do sześciu. Sześć małych prac... każdy kawałek pracy to jeden dodatek.

Cóż, nie wykonam pracy dodać je teraz. Ale wiem, jakie to będzie trudne. To będzie sześć dodań.

O nie, teraz mam więcej pracy. Sheesh. Kto robi takie rzeczy?!

Teraz proszą mnie o dodanie od jednego do dziesięciu! Dlaczego miałbym to zrobić? Nie chciałem dodawać jednego do sześciu. Dodać od jednego do dziesięciu ... cóż ... to byłoby jeszcze trudniejsze!

O ile trudniej byłoby? Ile jeszcze pracy będę musiał zrobić? Czy potrzebuję więcej czy mniej kroków?

Cóż, chyba będę musiał zrobić 10 dodań ... jeden za każdą rzecz od jednego do dziesięciu. Dziesięć to więcej niż sześć. Musiałbym pracować o wiele więcej, aby dodać od jednego do dziesięciu, niż od jednego do sześciu!

Nie chcę teraz dodawać. Chcę tylko pomyśleć, jak trudno byłoby dodać tyle. I mam nadzieję, że zagram jak najszybciej.

Dodać od jednego do sześciu, to jest jakaś praca. Ale czy widzisz, dodając od jednego do dziesięciu, to więcej pracy?

Big O jest twoim przyjacielem i moim. Big O pomaga nam myśleć o tym, ile pracy mamy do zrobienia, więc my mogę planować. A jeśli jesteśmy przyjaciółmi z big O, może nam pomóc wybrać pracę, która nie jest tak ciężka!

Teraz musimy wykonać nową pracę. O nie. Nie podoba mi się ta praca.

Nowa praca to: dodaj wszystko od jednego do n.

Czekaj! Co to jest n? Przegapiłem to? Jak Mogę dodać od jednego do n, jeśli nie powiesz mi, co to jest n?

Cóż, Nie wiem co to jest n. Nie powiedziano mi. Naprawdę? Nie? No cóż. Więc nie możemy pracować. UFF.

Ale choć nie zrobimy teraz możemy zgadnąć, jak ciężko byłoby, gdybyśmy znali N. musielibyśmy sumować n rzeczy, prawda? Oczywiście!

Nadchodzi wielki O, i powie nam, jak ciężka jest ta praca. On mówi: dodać wszystkie rzeczy od jednego do N, jeden po drugim, jest O (n). Aby dodać te wszystkie rzeczy, [Wiem, że muszę dodać N razy.] [1] to jest wielkie O! Mówi nam, jak ciężko jest wykonywać jakąś pracę.

Dla mnie, myślę o big O jak wielki, powolny, szef człowieka. Myśli o pracy, ale jej nie robi. On może powiedzieć: "Ta praca jest szybka."Albo, mógłby powiedzieć, "Ta praca jest tak powolna i ciężka!"Ale on nie wykonuje pracy. Po prostu patrzy na pracę, a potem mówi nam, ile to może zająć czasu.

Zależy mi na wielkim O. dlaczego? Nie lubię pracować! Nikt nie lubi pracować. Dlatego wszyscy kochamy big O! Mówi nam, jak szybko możemy pracować. Pomaga nam myśleć, jak ciężka jest praca.

Uh oh, więcej pracy. Nie róbmy tego. Ale, zróbmy plan, aby to zrobić, krok po kroku krok.

Dali nam talię dziesięciu kart. Wszystkie są pomieszane: siedem, cztery, dwa, sześć ... wcale nie prosto. I teraz... naszym zadaniem jest ich uporządkować.

Ergh. To brzmi jak dużo pracy!

Jak możemy posortować tę talię? Mam plan.

Przyjrzę się każdej parze kart, para po parze, przez talię, od pierwszej do ostatniej. Jeśli pierwsza karta w jednej parze jest duża, a następna karta w tej parze jest mała, wymieniam je. W przeciwnym razie idę do następnej pary, i tak dalej i tak on.. i wkrótce, pokład jest gotowy.

Kiedy talia jest skończona, pytam: czy wymieniłem karty w tym karnecie? Jeśli tak, to muszę to zrobić jeszcze raz, od początku.

W pewnym momencie, w pewnym momencie, nie będzie zamiany, a nasz rodzaj talii będzie gotowy. Tyle pracy!

Cóż, ile pracy by to było, sortowanie kart według tych zasad?

Mam 10 kart. I przez większość czasu, to znaczy, jeśli nie mam dużo szczęścia, muszę przejść przez całą talię do dziesięciu razy, z maksymalnie dziesięcioma swapami kart za każdym razem przez talię.

Big o, pomóż mi!

Big O wchodzi i mówi: dla talii n kart, sortowanie w ten sposób będzie zrobione w O(N kwadrat) czas.

Dlaczego on mówi n do kwadratu?

Cóż, wiesz n do kwadratu to N razy N. teraz rozumiem: N kart sprawdzonych, do tego, co może być N razy przez talię. Są to dwie pętle, każda z n krokami. To jest n kwadrat dużo pracy do zrobienia. Dużo pracy, na pewno!

Now when big O mówi, że zajmie O (N do kwadratu) pracy, nie ma na myśli n do kwadratu dodaje, na nosie. Może być trochę mniej, w niektórych przypadkach. Ale w najgorszym przypadku, będzie blisko N kwadratowe kroki pracy, aby posortować pokład.

Teraz tutaj big O jest naszym przyjacielem.

Big O zwraca uwagę na to: gdy n staje się duże, kiedy sortujemy karty, praca staje się znacznie trudniejsza niż stara praca just-add-these-things. Skąd to wiemy?

Cóż, jeśli n robi się naprawdę duży, nie obchodzi nas, co możemy Dodaj do n lub n do kwadratu.

Dla dużego n, n do kwadratu jest większe niż n.

Big O mówi nam, że sortowanie rzeczy jest trudniejsze niż dodawanie rzeczy. O(N do kwadratu) jest więcej niż O (N) dla dużego n. to znaczy: jeśli n staje się naprawdę duże, sortowanie mieszanej talii N rzeczy musi zająć więcej czasu, niż dodawanie n rzeczy mieszanych.

Big O nie rozwiązuje pracy za nas. Big O mówi nam, jak ciężka jest praca.

Mam talię kart. Posortowałem je. Pomogłeś. Dzięki.

Jest jest szybszy sposób na sortowanie kart? Czy big O może nam pomóc?

Tak, jest szybszy sposób! Nauka zajmuje trochę czasu, ale działa... i działa dość szybko. Możesz też spróbować, ale nie spiesz się z każdym krokiem i nie trać miejsca.

W ten nowy sposób sortowania talii, nie sprawdzamy par kart tak, jak robiliśmy to jakiś czas temu. Oto nowe zasady sortowania talii:

Po pierwsze: wybieram jedną kartę w części talii, nad którą teraz pracujemy. Możesz wybrać jeden dla mnie, jeśli chcesz. (Gdy robimy to po raz pierwszy, "część talii, nad którą teraz pracujemy", to oczywiście cała talia.)

Po drugie: rozklejam talię na tej karcie, którą wybrałeś. Co to jest splay; jak splay? Cóż, idę od karty startowej w dół, jeden po drugim, i szukam karty, która jest wyższa niż karta splay.

Trzy: idę od karty końcowej w górę i szukam karty, która jest bardziej Niska niż karta splay.

Gdy już znajdę te dwie karty, zamieniam je i idę dalej szukać więcej kart do wymiany. Oznacza to, że wracam do kroku drugiego, i splay na karcie wybrałeś trochę więcej.

W pewnym momencie ta pętla (od dwóch do trzech) zakończy się. Kończy się, gdy obie połowy tego wyszukiwania spotykają się na karcie splay. Następnie, po prostu splasyfikowaliśmy talię kartą, którą wybrałeś w pierwszym kroku. Teraz wszystkie karty w pobliżu początku są bardziej niskie niż karta splay; a karty w pobliżu końca są bardziej wysokie niż karta splay. Fajna sztuczka!

Four (and this is the fun część): mam teraz dwie małe talie, jedną niższą niż karta splay, a jedną wyższą. Teraz idę do kroku pierwszego, na każdym małym pokładzie! To znaczy, że zaczynam od pierwszego kroku na pierwszym małym pokładzie, a kiedy ta praca zostanie wykonana, zaczynam od pierwszego kroku na następnym małym pokładzie.

Rozkładam talię na części i sortuję każdą część, coraz mniejszą i coraz mniejszą, i w pewnym momencie nie mam już więcej pracy do wykonania. Teraz to może wydawać się powolne, ze wszystkimi zasadami. Ale uwierz mi, to wcale nie jest powolne. To jest dużo mniej pracy niż pierwszy sposób sortowania rzeczy!

Jak się ten rodzaj nazywa? To się nazywa szybkie sortowanie! Ten rodzaj został stworzony przez człowieka zwanego C. A. R. Hoare i nazwał go szybkim sortowaniem. Teraz szybkie sortowanie jest używane cały czas!

Szybkie sortowanie rozbija Duże talie na małe. Oznacza to, że rozbija duże zadania na małe.

Hmmm. Myślę, że może tam być jakaś zasada. Aby duże zadania były małe, rozbij je.

Ten rodzaj jest dość szybki. Jak szybko? Big O mówi nam: ten rodzaj wymaga O (N log n) pracy do wykonania, w średnim przypadku.

Czy jest mniej lub bardziej szybki niż pierwszy rodzaj? Big O, proszę pomóż!

Pierwszy rodzaj to O (N do kwadratu). Ale szybkie sortowanie to O (N log n). Wiesz, że n log n jest mniejsze niż n do kwadratu, Dla dużego n, prawda? Cóż, stąd wiemy, że szybkie sortowanie jest szybkie!

Jeśli musisz posortować talię, jaki jest najlepszy sposób? Możesz robić, co chcesz, ale ja wybieram szybkie sortowanie.

Dlaczego czy wybieram szybkie sortowanie? Nie lubię pracować, oczywiście! Chcę, żeby praca była wykonana jak najszybciej.

Skąd mam wiedzieć, że szybkie sortowanie to mniej pracy? Wiem, że O (n log n) jest mniejsze niż O (N kwadrat). O są bardziej małe, więc szybkie sortowanie to mniej pracy!

Teraz znasz mojego przyjaciela, Big O. pomaga nam mniej pracy. A jeśli znasz big O, możesz też mniej pracować!

Nauczyłeś się tego ze mną! Jesteś taki mądry! Dziękuję bardzo!

Now that work is done, Chodźmy się pobawić!

[1]: istnieje sposób na oszukiwanie i dodawanie wszystkich rzeczy od jednego do n, wszystko w jednym czasie. Jakiś dzieciak o imieniu Gauss odkrył to, gdy miał osiem lat. Nie jestem aż tak Bystra, więc nie pytaj mnie, jak on to zrobił.

Załóżmy, że mówimy o algorytmie A , który powinien coś zrobić z zestawem danych o rozmiarze n .

Wtedy O( <some expression X involving n> ) oznacza w prostym angielskim:

Jeśli masz pecha podczas wykonywania A, może to potrwać X(n) operacji do kompletna.

Tak się składa, że istnieją pewne funkcje (pomyśl o nich jako implementacje z X(n) ), które występują dość często. Są one dobrze znane i łatwo porównywane (przykłady: 1, Log N, N, N^2, N!, itd..)

Porównując je, gdy mówimy o a i innych algorytmach, łatwo jest uszeregować algorytmy według liczby operacji, które mogą (najgorszy przypadek) wymagać wykonania.

Ogólnie rzecz biorąc, naszym celem będzie znalezienie lub skonstruowanie algorytmu A w taki sposób, aby miał funkcję X(n), która zwraca jak najmniejszą liczbę.

Mam prostszy sposób na zrozumienie złożoności czasu najczęściej spotykaną metryką do obliczania złożoności czasu jest notacja Big O. To usuwa wszystkie stałe czynniki tak, że czas pracy można oszacować w stosunku do N jak n zbliża nieskończoność. Ogólnie można o tym myśleć tak:

statement;

Jest stała. Czas działania instrukcji nie zmieni się w stosunku do N

for ( i = 0; i < N; i++ )
  statement;

Jest liniowa. Czas pracy pętli jest wprost proporcjonalny do N. gdy N podwaja, podobnie jak czas trwania.

for ( i = 0; i < N; i++ ) 
{
for ( j = 0; j < N; j++ )
  statement;
}

Jest kwadratowy. Czas działania obu pętli jest proporcjonalny do kwadratu N. gdy n podwaja się, czas działania zwiększa się O N * N.

while ( low <= high ) 
{
 mid = ( low + high ) / 2;
 if ( target < list[mid] )
 high = mid - 1;
 else if ( target > list[mid] )
  low = mid + 1;
else break;
}

Jest logarytmiczna. Czas działania algorytmu jest proporcjonalny do liczby razy N można podzielić przez 2. Dzieje się tak dlatego, że algorytm dzieli obszar roboczy na pół z każdą iteracją.

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

Jest n * log ( N). Czas pracy składa się z N pętli (iteracyjnych lub rekurencyjne), które są logarytmiczne, a więc algorytm jest kombinacją liniową i logarytmiczną.

Ogólnie rzecz biorąc, robienie czegoś z każdym elementem w jednym wymiarze jest liniowe, robienie czegoś z każdym elementem w dwóch wymiarach jest kwadratowe, a dzielenie obszaru roboczego na pół jest logarytmiczne. Istnieją inne duże miary o, takie jak sześcienny, wykładniczy i pierwiastek kwadratowy, ale nie są one tak powszechne. Notacja Wielka O jest opisana jako O (), gdzie jest miarą. Algorytm quicksort byłby być opisane jako O ( N * log ( N)).

Uwaga: żadna z tych metod nie uwzględniła najlepszych, średnich i najgorszych przypadków. Każdy z nich ma swój własny zapis O. Zauważ również, że jest to bardzo uproszczone wyjaśnienie. Duże O jest najczęstsze, ale jest również bardziej złożone, że pokazałem. Istnieją również inne notacje, takie jak big omega, little o i big theta. Prawdopodobnie nie spotkasz ich poza kursem analizy algorytmów.

• Zobacz więcej na: tutaj

Powiedzmy, że zamawiasz Harry Potter: Complete 8-Film Collection [Blu-ray] z Amazon i pobierasz tę samą kolekcję filmów online w tym samym czasie. Chcesz sprawdzić, która metoda jest szybsza. Dostawa trwa prawie dzień, a pobranie ukończone około 30 minut wcześniej. Świetnie! Więc to ciasny wyścig.

A co jeśli zamówię kilka filmów Blu-ray jak Władca Pierścieni, Zmierzch, Trylogia Mrocznego Rycerza itp. i pobierać wszystkie filmy online w tym samym czasie? Tym razem dostawa trwa cały dzień, ale pobranie online trwa 3 dni. W przypadku zakupów online liczba zakupionych produktów (danych wejściowych) nie ma wpływu na czas dostawy. Wyjście jest stałe. Nazywamy to O (1) .

W przypadku pobierania online czas pobierania jest wprost proporcjonalny do rozmiaru pliku filmu (wejścia). Nazywamy to O (n) .

Z eksperymentów wiemy, że zakupy online skalują się lepiej niż pobieranie online. Bardzo ważne jest, aby zrozum notację big O, ponieważ pomaga analizować skalowalność i wydajność algorytmów.

Uwaga: notacja Big O reprezentuje najgorszy scenariusz algorytmu. Załóżmy, że O (1) i O (N) są najgorszymi scenariuszami powyższego przykładu.

Bibliografia : http://carlcheo.com/compsci

Jeśli masz w głowie odpowiednie pojęcie nieskończoności, to jest bardzo krótki opis:

Notacja Big O mówi o kosztach rozwiązania nieskończenie dużego problemu.

A ponadto

Czynniki stałe są nieistotne

Jeśli zaktualizujesz komputer, który może uruchomić twój algorytm dwa razy szybciej, notacja big O tego nie zauważy. Stałe ulepszenia czynnika są zbyt małe, aby można je było nawet zauważyć w skali, że duże o współpracuje z. Należy zauważyć, że jest to zamierzona część projektu notacji big O.

Chociaż cokolwiek "większego" niż stały czynnik można jednak wykryć.

Gdy interesuje Cię wykonywanie obliczeń, których rozmiar jest "duży" na tyle, że można go uznać za w przybliżeniu nieskończoność, wtedy notacja big O jest w przybliżeniu kosztem rozwiązania problemu.

Jeśli powyższe nie ma sensu, to nie masz w głowie zgodnego intuicyjnego pojęcia nieskończoności, a Ty powinienem chyba pominąć wszystkie powyższe; jedynym sposobem, jaki znam, aby te pomysły rygorystyczne, lub wyjaśnić je, jeśli nie są one już intuicyjnie użyteczne, jest najpierw nauczyć cię notacji big O lub czegoś podobnego. (chociaż, gdy dobrze zrozumiesz notację big O w przyszłości, może warto ponownie przyjrzeć się tym pomysłom)

Najprostszy sposób na to (w prostym języku angielskim)

Staramy się zobaczyć, jak liczba parametrów wejściowych wpływa na czas działania algorytmu. Jeśli czas działania aplikacji jest proporcjonalny do liczby parametrów wejściowych, to mówi się, że jest w dużym O od n.

Powyższe stwierdzenie jest dobrym początkiem, ale nie do końca prawdą.

Dokładniejsze wyjaśnienie (matematyczne)

Przypuśćmy

N = Liczba wejść parametry

T (n) = rzeczywista funkcja wyrażająca czas działania algorytmu jako funkcja n

C = stała

F (n) = Funkcja przybliżona, która wyraża czas działania algorytmu jako funkcję n

Wtedy, jeśli chodzi o Duże O, przybliżenie f (n) jest uważane za wystarczająco dobre, o ile poniższy warunek jest prawdziwy.

lim     T(n) ≤ c×f(n)
n→∞

Równanie odczytuje się jako Gdy n zbliża się do nieskończoności, T z n jest mniejsze lub równe C razy f z n.

W notacji big O zapisuje się to jako

T(n)∈O(n)

To jest odczytywane jako T z n jest w wielkim O z n.

Back to English

Na podstawie powyższej definicji matematycznej, jeśli mówisz, że Twój algorytm jest dużym O Z N, oznacza to, że jest funkcją n (liczba parametrów wejściowych) lub szybszą . Jeśli twój algorytm jest dużym O Z n, to jest również automatycznie dużym o z N kwadratu.

Wielkie O Z n oznacza, że mój algorytm działa co najmniej tak szybko jak ten. Nie możesz spójrz na notację Big O twojego algorytmu i powiedz, że jest powolny. Możesz tylko powiedzieć, że to szybko.

Sprawdź to aby zobaczyć samouczek wideo o Big O z UC Berkley. To właściwie prosta koncepcja. Jeśli usłyszysz profesora Shewchucka (aka nauczyciela poziomu Boga) wyjaśniającego to, powiesz: "Och, to wszystko!".

Jakie jest proste angielskie Wyjaśnienie notacji "Big O"?

Bardzo Szybka Notka:

• "Big O" robi dwie rzeczy:

  1. szacuje, ile kroków metody komputera stosuje się do wykonania zadania.
  2. ułatwienie procesu porównywania z innymi w celu ustalenia, czy jest to dobre, czy nie?
  3. "Big O' osiąga powyższe dwa ze znormalizowanymi Notations.

• Istnieje siedem najczęściej używanych notacji

  1. O(1), oznacza, że Twój komputer wykonuje zadanie za pomocą 1 step, jest doskonały, zamówiony nr 1
  2. o(logN), oznacza, że Twój komputer ukończy zadanie z logN krokami, jest dobry, zamówiony nr 2
  3. O(N), Zakończ zadanie za pomocą N kroków, jego sprawiedliwego, porządku Nr 3
  4. O(NlogN), kończy zadanie z O(NlogN) krokami, nie jest dobrze, rozkaz nr 4
  5. O(N^2), Wykonaj zadanie za pomocą N^2 kroków, jest źle, Zamówienie nr 5
  6. O(2^N), wykonaj zadanie za pomocą 2^N kroków, to straszne, rozkaz nr 6
  7. O (N!w tym celu należy skontaktować się z działem obsługi klienta.]}

Załóżmy, że otrzymujesz notację O(N^2), nie tylko jesteś pewny, że metoda wykonuje N * N kroków, aby wykonać zadanie, także Ty zobacz, że nie jest dobry jak O(NlogN) z jego rankingu.

Zwróć uwagę na kolejność na końcu linii, dla lepszego zrozumienia.Jest więcej niż 7 notacji, jeśli wszystkie możliwości są brane pod uwagę.

W CS zbiór kroków do wykonania zadania nazywa się algorytmami.
W terminologii notacja Big O jest używana do opisu wydajności lub złożoności algorytmu.

Dodatkowo Big O określa najgorszy przypadek lub mierzy górne stopnie.
Można odnieść się do Big-Ω (Big-Omega) dla najlepszego przypadku.

Big-Ω (Big-Omega) notacja (artykuł) / Khan Academy

• Podsumowanie
  "Big O" opisuje wydajność algorytmu i ocenia go.

  "Big O" klasyfikuje algorytmy i standaryzuje proces porównywania.

Jest to bardzo uproszczone wyjaśnienie, ale mam nadzieję, że obejmuje najważniejsze szczegóły.

Powiedzmy, że Twój algorytm radzenia sobie z problemem zależy od pewnych 'czynników', na przykład niech będzie to N I X.

W zależności od N I X, Twój algorytm będzie wymagał pewnych operacji, na przykład w najgorszym przypadku są to operacje 3(N^2) + log(X).

Ponieważ Big-O nie dba zbytnio o stały czynnik (aka 3), Big-O twojego algorytmu to O(N^2 + log(X)). To w zasadzie tłumaczy " ilość operacje Twój algorytm potrzebuje dla najgorszego przypadku skaluje się z tym'.

definicja: - notacja Big O jest notacją, która mówi, jak wydajność algorytmu będzie działać, jeśli Dane wejściowe zwiększą się.

Kiedy mówimy o algorytmach, są 3 ważne filary wejścia, wyjścia i przetwarzania algorytmu. Big O to notacja symboliczna, która mówi, że jeśli Dane wejściowe zostaną zwiększone, z jaką szybkością będzie się różnić wydajność przetwarzania algorytmu.

Zachęcam do obejrzenia tego filmiku na youtube, który wyjaśnia Big O Zapis w szczegółach z przykładami kodu.

Więc na przykład załóżmy, że algorytm zajmuje 5 rekordów, a czas wymagany do przetworzenia tego samego wynosi 27 sekund. Jeśli zwiększymy rekordy do 10, algorytm zajmie 105 sekund.

W prostych słowach czas jest kwadratem liczby rekordów. Możemy to oznaczać przez O (N ^ 2). Ta symboliczna reprezentacja jest określana jako notacja Big O.

Teraz zwróć uwagę, że jednostki mogą być wszystko w wejściach może to być bajty, liczba bitów rekordów, wydajność może być mierzona w dowolnej jednostce , takiej jak sekunda , minuty, dni i tak dalej. Więc to nie jest dokładna jednostka, ale raczej związek.

Na przykład spójrz na poniższą funkcję "Function1", która pobiera zbiór i przetwarza na pierwszym rekordzie. Teraz dla tej funkcji wydajność będzie taka sama bez względu na to, czy umieścisz 1000, 10000 lub 100000 rekordów. Więc możemy to oznaczać przez O (1) .

void Function1(List<string> data)
{
string str = data[0];
}

Zobacz teraz poniższą funkcję"Function2 ()". W tym przypadku czas przetwarzania zwiększy się wraz z liczbą rekordów. Wydajność algorytmu możemy określić za pomocą O (N) .

void Function2(List<string> data)
        {
            foreach(string str in data)
            {
                if (str == "shiv")
                {
                    return;
                }
            }
        }

Gdy widzimy duży zapis O dla dowolnego algorytmu, możemy klasyfikować go do trzech kategorii wydajności: -

1. Log and constant category: - każdy programista chciałby zobaczyć wydajność swojego algorytmu w tej kategorii.
/ Align = "Left" / Linear nie będzie chciał zobaczyć algorytmów w tej kategorii, dopóki nie zostanie ostatnia opcja lub jedyna opcja.
2. wykładniczy: - tutaj nie chcemy widzieć naszych algorytmów i potrzebna jest przeróbka.

Więc patrząc na notację Big O kategoryzujemy dobre i złe strefy dla algorytmów.

Https://www.youtube.com/watch?v=k6kxtzICG_g

Jeśli chcę wyjaśnić to 6-letniemu dziecku, zacznę rysować niektóre funkcje f (x) = X i F(x) = X^2 na przykład i zapytam dziecko, która funkcja będzie górną Funkcją na górze strony. Następnie przejdziemy do losowania i zobaczymy, że X^2 wygrywa. "Kto wygrywa" jest właściwie funkcją, która rośnie szybciej, gdy x dąży do nieskończoności. Tak więc "funkcja x jest w dużym O Z X^2" oznacza, że X rośnie wolniej niż X^2, Gdy x zmierza do nieskończoności. To samo można zrobić, gdy X ma tendencję do 0. Jeśli narysujemy te dwie funkcje dla x od 0 do 1 x będą funkcją górną, więc "funkcja x^2 jest w dużym O Z X dla X dąży do 0". Kiedy dziecko będzie starsze dodam, że naprawdę duże O może być funkcją, która rośnie nie szybciej, ale tak samo jak dana funkcja. Ponadto stała jest odrzucana. Więc 2x jest w Wielkim O Z X.