Tekst źródłowy strony Wstęp do programowania/Wstęp do algorytmów

{{powrot|Wstęp do programowania|}}
==Wprowadzenie do algorytmów==

[[Image:alch.jpg||thumb|right|200px|Al Chuwarizmi (ok. 780–ok. 850)]]
Najważniejszym pojęciem w informatyce jest algorytm. Nazwa ta ma swoje korzenie w średniowieczu i wzięła się ze zniekształconego nazwiska wielkiego uczonego arabskiego Al Chuwarizmiego, który żył na przełomie VIII i IX wieku i pochodzącego z Chorezmu. Al Chuwarizmi, działając w Domu Nauk kalifa Al Mamuna w Bagdadzie, opublikował ważne dzieła matematyczne, wśród nich Hisab al dżabr w'al muqabala – traktat o rozwiązywaniu równań, z którego wzięła nazwę algebra – jeden z głównych działów matematyki. W traktacie tym, poza wprowadzeniem systemu zapisu pozycyjnego, zaczerpniętego od Hindusów, a zwanego arabskim, podał między innymi metody rozwiązywania równań kwadratowych. Metody te odwoływały się do pojęć geometrycznych; utożsamiano wtedy liczby i działania z miarami obiektów geometrycznych. Liczby rzeczywiste to były długości odcinków, dodawanie to było sklejanie odcinków, mnożenie odpowiadało wyliczaniu pola prostokąta o danych bokach, a pierwiastkowanie wyznaczaniu boku kwadratu o zadanym polu. Arabowie, podobnie jak starożytni Grecy, nie znali pojęcia liczby ujemnej, stąd, gdy dziś patrzymy na metody Al Chuwarizmiego, poza oczywistym pięknem, wydają się nam one nieco dziwaczne. Ale cóż – wtedy inaczej po prostu się nie dało. 

W pierwszym kroku rozwiązania Al Chuwarizmi polecał podzielić wszystkie współczynniki trójmianu kwadratowego przez współczynnik przy <math>x^{2}</math>, aby uwolnić się od jednego z nich; w końcu pierwiastki przez takie podzielenie nie zmieniają się, a metoda staje się prostsza. 
Al Chuwarizmi rozważał zatem równania postaci <math>x^{2}+bx+c</math> dla różnych klas b i c: dodatnich, ujemnych i równych zero. Miał zatem do czynienia z 9 różnymi przypadkami i dla każdego z nich podał metodę wyznaczania pierwiastka takiego równania. Przyjrzyjmy się jednemu z nich: dane są zaczerpnięte bezpośrednio z omawianej księgi. Rozwiązujemy równanie

<center><math>x^{2}+10x = 39</math></center>

Jest to zatem równanie z klasy równań, w których  współczynnik przy x jest dodatni, a wyraz wolny ujemny (dla wygody przenieśliśmy go na prawą stronę, więc po tamtej stronie jawi się nam jako c dodatnie). Oto co proponował Al Chuwarizmi. 


[[Grafika:ryc1.jpg|frame|center|Geometryczne rozwiązanie równania <math>x^2+10x=39</math>]]


Rysujemy kwadrat o boku x. Po jednej jego stronie doklejamy prostokąt o bokach x oraz <math>10/2 = 5</math>, po drugiej pod kątem prostym identyczny prostokąt. Uzupełniamy powstały kąt prosty wyznaczony przez 2 odcinki długości 5 do kwadratu i otrzymujemy duży kwadrat, którego pole wynosi 

<center><math>x^{2} + 5x + 5x + 25= 39 + 25 = 64</math></center>

Bok tego dużego kwadratu ma więc długość 8, a że powstał on przez sklejenie odcinka o długości x oraz odcinka o długości 5, więc <math>x = 3</math>. Drugi pierwiastek w tym przypadku nas nie interesuje: jest ujemny, a więc go "nie ma" – liczby ujemne nie istniały wówczas w świadomości współczesnych. 

Zauważmy, że konstrukcję tę, a zatem i stosowne obliczenia, można powtórzyć dla każdej pary (b,c) w której b&nbsp;>&nbsp;0, zaś c&nbsp;<&nbsp;0. Wyrażając jednym wzorem efekt obliczeń uzyskalibyśmy wyrażenie 

<span id="RownanieKwadratowe"/> 
<center><math>
x=\sqrt{c+\left(\frac{b}{2}\right)^2}-\frac{b}{2}
</math></center>

Obliczenie wartości x mogłoby się odbywać według następującego schematu:
#podziel <math>b</math> przez <math>2</math> i zapamiętaj wynik na zmiennej pomocniczej <math>b'</math>
#podnieś <math>b'</math> do kwadratu
#dodaj do otrzymanej liczby wartość <math>c</math> 
#wyciągnij z otrzymanej sumy pierwiastek kwadratowy
#odejmij od tego, co uzyskałeś uprzednio zapamiętaną wartość <math>b'</math> 
#otrzymana liczba jest szukanym (nieujemnym) pierwiastkiem równania <math>x^{2}+bx=c</math>.
Zróbmy parę obserwacji. 

Po pierwsze powyższa procedura jest wykonywalna dla każdych danych b,c>0. Zauważmy, że jedyna operacja, która mogłaby sprawić kłopoty z wykonaniem, to odejmowanie w punkcie 5 naszej procedury. Jednak można łatwo sprawdzić, że daje ono zawsze wynik dodatni: 

<center>w końcu dla <math>c >0</math> mamy <math>\sqrt{c+\left(\frac{b}{2}\right)^2} > \sqrt{\left(\frac{b}{2}\right)^2}=\frac{b}{2}</math>.</center>
 
Po drugie, zastosowaliśmy tu pewne niewielkie, ale ważne uproszczenie algorytmu: użyliśmy w jego opisie pomocniczej zmiennej <math>b'</math>, dzięki której nie musieliśmy dwukrotnie dzielić wartości <math>b</math> przez <math>2</math>.
Po trzecie, zapisując wzór [[#RownanieKwadratowe|na równanie kwadratowe]] skorzystaliśmy z tradycji notacyjnej, w myśl  której w wyrażeniach arytmetycznych zawsze wiadomo, w jakiej kolejności wykonuje się działania. W szczególności w wyrażeniu podpierwiastkowym najpierw dzieliliśmy&nbsp;b przez&nbsp;2, potem podnosiliśmy wynik do kwadratu, a na końcu dodawaliśmy do niego&nbsp;c. To, co w podanym przez Al Chuwarizmiego przepisie wymagało uściślenia kolejności, można wyrazić wzorem w zwartej formie, umówiwszy się zawczasu co do interpretacji podanej notacji. Niezwykle ważne jest, aby używana notacja była jednoznaczna i abyśmy nie popełniali błędu przy interpretacji wyrażeń, w szczególności żebyśmy byli zgodni co do kolejności wykonywanych działań. Wrócimy do tego zagadnienia w wykładzie o gramatykach. 


{{cwiczenie||pytanie|
*Jak będzie działała podana metoda, dla c<realnowiki><realnowiki><nowiki> = </nowiki></realnowiki></realnowiki>0?
*Zaprojektuj geometryczną metodę w stylu Al Chuwarizmiego dla równania <math>x^{2}= 5x + 6</math>. Czy metoda ta da poprawne wyniki dla wszystkich równań postaci <math>x^{2} = bx + c</math> przy  dodatnich b, c? 
}}

Co to są zatem algorytmy? Ogólnie określamy tym mianem wszelkie przepisy postępowania, które 
doprowadzają do uzyskania pożądanego efektu – rozwiązania zadania. W potocznej mowie mówimy czasem o algorytmach postępowania niewiele mających wspólnego z komputerami, jednak dla informatyków algorytmy wiążą się nierozerwalnie z programowaniem. 

Prawdziwe problemy pojawiają się, gdy chcemy algorytm zakodować w taki sposób, żeby był dobrze wykonany przez maszynę. Nie możemy sobie pozwolić na odwoływanie się do doświadczenia, machanie rękami, domysły. Komputer niczego się nie domyśla, ba, nie rozumie języka naturalnego i potrzebna będzie nam precyzyjna notacja do komunikacji z nim. Istotą programowania jest bowiem wyrażanie algorytmów w sposób ścisły, podlegający rygorom skończonej liczby reguł, których znaczenie w jednoznaczny sposób jesteśmy określić. 

Al Chuwarizmi nie był oczywiście pierwszym człowiekiem, który stosował podejście algorytmiczne do rozwiązywania problemów. W rzeczywistości każdy z nas stosuje algorytmy w rozmaitych sytuacjach życiowych. Człowiek pierwotny miał algorytm polowania na mamuty, czy rozpalania ognia. Dzisiaj często wykonujemy pewne algorytmy, nie zdając sobie sprawy. Warto przytoczyć parę przykładów algorytmów z życia codziennego:

<table>
  <tr valign="top"><td>[[Grafika:przepis.jpg]]</td><td> '''Przepisy kucharskie''' Typowy przepis zawiera deklaracje obiektów (składników pichcenia) ich początkowe wartości (miary) oraz opis działań doprowadzający do przyrządzenia potrawy.</td></tr> 

<tr valign="top"><td>[[Grafika:nuty.jpg]]</td><td>'''Zapis nutowy muzyki'''. Za pomocą szczególnego systemu notacyjnego określa się wysokości i względne czasy trwania nut i pauz między nimi. Można również i tu określić dane: są to zazwyczaj określenia instrumentów, które w partyturze występują, oraz dane początkowe, takie jak metrum czy dynamika poszczególnych części. Zauważmy, że poza standardowymi znakami na pięciolinii, kompozytorzy często stosują dodatkowe określenia takie jak crescendo, poco allegretto, piano, con fuoco itp, pozwalające wykonawcy lepiej wyczuć ich intencje.  Szczególnie atrakcyjnie wyglądają niektóre nuty kompozytorów współczesnych, którzy odchodzą czasem od tradycyjnego zapisu nutowego i starają się niekiedy wymyślić i opisać własny system notacyjny, wyrażający ich intencje.</td></tr>

<tr valign="top"><td>[[Grafika:narzedzia2.jpg]]</td><td>'''Instrukcje montażu''' Często do zestawów mebli, czy klocków lego, dołączona jest kartka z instrukcją montażu zapisaną za pomocą sekwencji rycin obrazujących kolejne fazy powstawania składanego obiektu. Użytkownik, porównując zmiany na poszczególnych obrazkach, ma się domyślić, jakie czynności, w jakiej kolejności i za pomocą jakich części ma wykonywać. Zauważmy, że i tu występuje charakterystyczny dla algorytmów  opis danych: najczęściej zestaw części składowych jest wyrysowany obok historyjki obrazkowej z zaznaczeniem liczby poszczególnych elementów.</td></tr>
<tr valign="top"><td>[[Grafika:mapa.jpg]]</td><td>'''Opisy dojazdu''' Wyjaśniając jak dotrzeć do danego miejsca (mappy.com), wiele serwisów udostępnia opis drogi z zaznaczeniem kluczowych punktów i decyzji.</td></tr>
<tr valign="top"><td>[[Grafika:kroki.jpg]]</td><td>'''Opis układów choreograficznych, scenopisy przedstawień''' Tutaj też stosuje się specyficzną symbolikę i skróty notacyjne.</td></tr> </table>

Takich przykładów można przytaczać tysiące. Właściwie niemal wszystko, co robimy, podlega jakiemuś algorytmowi działania – przy czym warto podkreślić, że ludzie nie muszą mieć algorytmów objaśnianych dokładnie: wiele mogą wywnioskować z kontekstu, doświadczenia, po prostu domyślając się, o co może chodzić. Kucharce nie trzeba wyjaśniać, co to znaczy "zeszklić cebulkę na ciemnozłoty kolor", a monterowi - co znaczy "zaizolować przewody". 

Z komputerami jest jednak inaczej. Są to wyjątkowo głupie urządzenia i jeśli dokładnie nie wytłumaczymy, co mają zrobić, stają się bezradne. Między bajki należy włożyć rozmaite sytuacje znane z literatury fantastyczno-naukowej, w których komputery są równorzędnymi partnerami intelektualnymi dla ludzi. Sztuczna inteligencja, nawet jeśli istnieje, bazuje na ściśle określonych algorytmach działania i nie ma tam miejsca na intuicję, domyślenie się czegokolwiek czy nagłe olśnienie, które są doskonale znane istotom myślącym. Ludzie często nie zdają sobie sprawy, jak wiele w algorytmach, którymi się posługują, zależy od nieuświadamianego kontekstu, jak dużo muszą dopowiadać do rzekomo precyzyjnych procedur działania. Komputery bezlitośnie wyłapują luki w specyfikacji procedur i nie ma mowy, żeby domyśliły się, że wykonują jakąś bezsensowną akcję, typu wydrukowanie żądania zapłacenia 0 zł. Jeśli wyraźnie nie zapiszemy w algorytmie, że takich żądań nie należy generować, to komputer ślepo wykona nasze polecenie, choćby było ono w oczywisty sposób bezsensowne. W dalszych wykładach zobaczymy przykłady, w których algorytmy z pozoru wyglądające na poprawne i kompletne, będą miały luki powodujące błędne działanie. 

{{cwiczenie||pytanie2|
Znajdź w Internecie przykłady bezsensownego zachowania się komputerów. Spróbuj domyślić się, jakiego rodzaju błąd programisty był przyczyną kompromitacji. 
}}

Spróbujmy przymierzyć się do problemu znanego jeszcze ze starożytności. Przy dodawaniu sprowadza się mianowniki do najmniejszej wspólnej wielokrotności. Wyznaczenie jej najczęściej polega na tym, że oblicza się największy wspólny dzielnik, dzieli się jedną z liczb przez niego i wynik mnoży przez                    drugą. Jak jednak znaleźć największy wspólny dzielnik?

==Operacja dzielenia z resztą==
 
 Dla danych liczb całkowitych x, y, z zastrzeżeniem, że <math>y \neq 0</math> określamy dwie operacje: 
 wynik i resztę z dzielenia x przez y następująco:
 &nbsp;&nbsp;<math>x \div y = c</math>,
 &nbsp;&nbsp;<math>x \bmod y = r</math>, 
 gdzie liczby c i r spełniają następujące zależności:
 &nbsp;&nbsp;<math>x = cy + r</math> 
 oraz 
 &nbsp;&nbsp;<math>0 \le r < |y|</math>


{{przyklad|||
<math>11\div 3 = 3</math>,

<math>11\bmod 3 = 2</math>,

<math>-7\div 2 = -4</math>,

<math>-7\bmod 2 =1</math>,

<math>7\div -2 = -3</math>,

<math>7\bmod -2 = 1</math>,
}}

{{cwiczenie||pytanie3|
Czy zawsze <math>x\bmod -y = -x \bmod  y</math> oraz <math>x\div (-y) =  (-x) \div y</math>?
}}


<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Wskazówka </span>
<div class="mw-collapsible-content" style="display:none">Sprawdź hipotezę dla x= -7, y=3 oraz x=7, y=-3
</div>
</div>



<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Odpowiedź</span>
<div class="mw-collapsible-content" style="display:none">Nie. Na przykład <math>7\div -3 = -2, -7 \div 3 = -3</math>, bo <math>7 = (-2)(-3) + 1</math>, a <math>-7 =(-3) \cdot 3 + 2</math>.
</div>
</div>
 
{{problem||problem 1|[NWD(a,b)]:
Dane są dwie liczby całkowite nieujemne <math>a</math>, <math>b</math> takie, że <math>a + b > 0</math>. Wyznacz największą liczbę naturalną <math>d</math> taką, że <math>a\bmod d</math> <realnowiki><realnowiki><nowiki>= </nowiki></realnowiki></realnowiki>0 i <math>b \bmod d= 0</math>. Liczbę tę nazywamy największym wspólnym dzielnikiem <math>a</math> i <math>b</math> oraz oznaczamy przez <math>(a, b)</math>. 
}}

Zauważmy, że zawsze <math>(a, b)=(b, a)</math>. 

Załóżmy więc od tej pory, że <math>a\ge b</math>.

==Algorytm Euklidesa== 
[[Image:euklides.jpg||thumb|right|200px|Euklides (ok. 365p.n.e.-ok. 300p.n.e)]]
Wiadomo, że nie istnieje ogólny wzór na największy wspólny dzielnik. Jak więc go można wyznaczyć? Metoda, którą poznamy, to jeden z najstarszych spisanych algorytmów zwany '''algorytmem Euklidesa''', od imienia jednego z największych matematyków w całej historii, który go opublikował w swoim wiekopomnym dziele „Elementy”.  [[http://pl.wikipedia.org/wiki/Elementy Elementy]]

Euklides zauważył, że gdy mniejsza z liczb jest równa zero, to największy wspólny dzielnik jest równy drugiej z nich, a gdy obie są dodatnie, to jest równy największemu wspólnemu dzielnikowi ich różnicy oraz mniejszej z nich. ref{MatematykaDyskretna...} Zapisując to zdanie za pomocą wzoru otrzymujemy

<span id="RownanieKwadratowe"/> 
<center><math>(a, b) = \begin{cases}a & \mbox{ jeśli } b = 0 \\(a-b, b) & \mbox{ jeśli }  b > 0\end{cases}</math></center>

Taki wzór jak powyżej nazywamy '''rekurencyjnym'''. Istotą definiowania rekurencyjnego jest odwoływanie się w definicji jakiegoś pojęcia do niego samego, zazwyczaj zastosowanego dla prostszych danych. Tak jak tutaj: żeby zdefiniować  największy wspólny dzielnik, wykorzystujemy w definicji też pojęcie największego wspólnego dzielnika, tylko dla nieco mniejszych argumentów. Na dobrą sprawę taka definicja wygląda nieco podejrzanie, ale w rzeczywistości jest całkowicie poprawna. W końcu za jej pomocą jesteśmy  w stanie obliczyć największy wspólny dzielnik dla dowolnej pary argumentów. Spróbujmy: 
<center><tt>
(84,36)=(48,36)=(12,36)=(36,12)=(24,12)=(12,12)=(0,12)=(12,0)=12</tt></center>

W ciągu tym odejmowaliśmy od pierwszego argumentu drugi, a gdy wynik okazywał się od niego mniejszy, zamienialiśmy argumenty miejscami. Czy możemy być pewni, że zawsze w ten sposób postępując otrzymamy w końcu jeden z argumentów równy zero?

{{cwiczenie||pytanie5|
Udowodnij, że zawsze w skończonej liczbie kroków zejdziemy z jednym argumentem do zera.
}} 


<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Wskazówka </span>
<div class="mw-collapsible-content" style="display:none">Rozważ, jak zachowuje się suma argumentów w badanym ciągu.
</div>
</div>



<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Odpowiedź</span>
<div class="mw-collapsible-content" style="display:none">Oba argumenty po każdym kroku są nieujemne, więc nieujemna jest też ich suma. Suma argumentów po każdym kroku maleje, a nie może ciąg liczb naturalnych ściśle maleć w nieskończoność – jego długość jest ograniczona przez początkową wartość tej sumy: w końcu jej wartość w każdym kroku pomniejsza się co najmniej o jedynkę. Zatem ciąg naszych operacji jest skończony. A jedyny powód przerwania obliczeń rekurencyjnych może być tylko taki, że mniejszy z argumentów równa się zero.
</div>
</div>
 


Zauważmy, że podaliśmy ''przepis'' otrzymywania  największego wspólnego dzielnika. Jest to właśnie ''algorytm Euklidesa''. Za jego pomocą możemy znaleźć największy wspólny dzielnik dla dowolnej pary argumentów. 

Przedstawmy program w notacji, którą formalnie wprowadzimy nieco później, obliczający  największy wspólny dzielnik zgodnie z podanym algorytmem. 
===Euklides 1===
{{kotwica|kod_zrodlowy|}}

 '''Read'''(a,b);             //Wczytujemy a i b, zakładając że użytkownik wie, że a>=b, a+b>0 
   '''while''' b > 0 '''do''' 
   '''begin'''
    '''if''' a< b '''then''' zamień(a,b);  //po wykonaniu tej instrukcji zawsze a>=b
     a:=a-b                //tutaj być może raz wykonamy niepotrzebnie odejmowanie zera 
   '''end''';
   '''Write'''(a)                //wypisujemy wynik, którym jest wartość a


Zastanówmy się, jak długo będziemy wykonywali nasz algorytm. Załóżmy, że dane na których pracujemy nie przekraczają <math>10^{30}</math>. Tak duże liczby jako argumenty nie są jakimś dziwactwem: w rzeczywistości szukanie  największego wspólnego dzielnika jest częścią szyfrowania RSA – powszechnie stosowanego protokołu kryptograficznego i zazwyczaj używa się tu znacznie większych liczbach – ponadstucyfrowych. 

Dobierzmy możliwie złośliwe dane. Oczywiście aby algorytm działał jak najdłużej, należy odejmować jak najmniejsze wartości w każdym kroku. Weźmy zatem <math>a = 10^{30}, b = 1</math>. Widać, że dla tych danych wykona się <math>10^{30}</math> obrotów pętli: będziemy żmudnie odejmowali jedyneczkę od sporej dość liczby. Jak długo to może potrwać?

Przyjmijmy, że mamy do czynienia z bardzo szybkim komputerem, który na jeden obrót pętli potrzebuje jedną dziesięciomiliardową sekundy <math>(10^{-10}s )</math>. Zatem  w ciągu doby mamy <math>86400\cdot 10^{10}</math> obrotów pętli. Dób w ciągu roku jest 365, czyli razem mamy <math>31536 \cdot 10^{13}</math> obrotów pętli na rok. A od Wielkiego Wybuchu minęło niespełna 14 miliardów lat, łącznie niespełna <math>5 \cdot 10^{28}</math> obrotów pętli. Przyjąwszy, że ktoś włączył nasz komputer na początku Wszechświata i on do dziś z tą zawrotną prędkością wykonuje nasz program dla tych właśnie danych, widzimy, że do dziś wykonałby niespełna jedną dwudziestą wszystkich obliczeń. Jeszcze dwadzieścia parę takich Wszechświatów i program zakończyłby swoje działanie. 

Co należy w takiej sytuacji zrobić? Niektórzy myślą, że trzeba kupić szybszy komputer. 
Żarty na bok. Ale istnieją użytkownicy, którzy gdy im program działa zbyt wolno, myślą przede wszystkim o sprzęcie. W wielu przypadkach jednak główne rezerwy tkwią w samym algorytmie. Dlatego też w trakcie tego kursu będziemy wielką wagę przykładali do jakości algorytmów i szukali jak najlepszych rozwiązań. 

Zauważmy (a Euklides to wiedział długo przed nami), że tak naprawdę odejmowanie wykonujemy tylko po to, żeby wyznaczyć resztę z dzielenia <math>a</math> przez <math>b</math>. W końcu dopóki <math>a</math> jest większe od <math>b</math>, odejmujemy od <math>a</math> całkowite wielokrotności <math>b</math>, a zamieniamy rolami <math>a</math> z <math>b</math> gdy tylko <math>a</math> spadnie poniżej <math>b</math>. W momencie, gdy <math>a</math> z <math>b</math> zamieniają się rolami, <math>a</math> ma wartość właśnie reszty z dzielenia <math>a</math> przez <math>b</math>. Można by zatem pominąć całe to odejmowanie, jeśli udałoby się nam od razu znaleźć tę resztę z dzielenia. A to nie jest takie trudne – można choćby stosować poznane w szkole podstawowej słupkowe dzielenie, które nad kreską daje wynik dzielenia, a na dole – resztę. Zmodyfikujmy zatem algorytm Euklidesa:

===Euklides 2===
{{kotwica|kod_zrodlowy|}}

 '''Read'''(a,b);        //Wczytujemy a i b, zakładając że użytkownik wie, że a>=b, a+b>0 
 '''while''' b > 0 do 
 '''begin'''
   a:=a mod b;                     
   zamień (a,b) //reszta jest zawsze mniejsza od dzielnika, więc w ciemno możemy
                  zamienić a z b
 '''end''';
 '''Write'''(a)          //Wypisujemy wynik

Podobnie jak poprzednio, możemy bez trudu pokazać, że program się zawsze zakończy. 

Jak długo się tym razem będzie wykonywała nasza pętla programu? Jeśli dobranie najbardziej złośliwych danych w poprzednim przypadku było proste, to teraz wcale nie jest oczywiste dla jakich danych spośród liczb 30-cyfrowych program będzie działał najdłużej. Załóżmy, że tak jak wcześniej interesuje nas liczba obrotów pętli. Pomijamy na razie koszt związany z operacją dzielenia z resztą, zakładając że jest on stały. 

{{cwiczenie||pytanie6|
Znajdź dwie liczby dwucyfrowe, dla których algorytm Euklides 2 wykona się najwięcej razy. 
}}


<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Wskazówka 1</span>
<div class="mw-collapsible-content" style="display:none">Maksymalna liczba obrotów pętli, to 9. </div>
</div>



<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Wskazówka 2</span>
<div class="mw-collapsible-content" style="display:none">Nie bądź rozrzutny: jeśli tę samą liczbę obrotów pętli możesz uzyskać wychodząc od mniejszych argumentów, to zrób to.
</div>
</div>



<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Odpowiedź</span>
<div class="mw-collapsible-content" style="display:none"><math>(89, 55)</math>. Wykonując kolejne dzielenia z resztą otrzymujemy ciąg <math>(55, 34)\, (34, 21)\, (21, 13)\, (13,8)\, (8,5)\, (5, 3)\, (3,2)\, (2,1)\, (1,0)</math>. Za każdym razem wynik dzielenia był równy jeden, a reszta była po prostu różnicą argumentów. 
</div>
</div>

==Liczby Fibonacciego==

[[Image:fibonacci.jpg||thumb|right|200px|Fibonacci (ok. 1170-1250)]]
Aby rozwiązać ten problem doboru najbardziej złośliwych danych, należy spojrzeć na problem od drugiej strony: jak za pomocą najmniejszych liczb uzyskać z góry zadaną liczbę obrotów pętli? Widać, że aby pętla wykonała się raz, wystarczą dane <math>(1, 1)</math>. Ale te dane nie mogą być wynikiem wcześniejszego obrotu pętli: pamiętajmy, że pierwszy z argumentów jest zawsze dzielnikiem z poprzedniego obrotu pętli, a skoro jest nim jedynka, to reszta nie mogła być równa jeden. Zatem przy więcej niż jednym obrocie pętli najmniejsze dane dla ostatniego obrotu pętli, to <math>(2, 1)</math> (po czym dostajemy od razu parę <math>(1, 0)</math> kończącą pętlę). Jakie były zatem dane przedostatnie? Widać, że dzieliliśmy przez <math>2</math> i dostaliśmy resztę <math>1</math>. Zatem w poprzednim kroku mogliśmy mieć pary <math>(3, 2)</math> lub <math>(5, 2)</math> lub <math>(7, 2),\ldots</math>. Z nich para <math>(3, 2)</math> jest najoszczędniejsza – są to liczby, które dają najmniejszą sumę, a liczba obrotów naszej pętli jest równa <math>2</math>. Jak wyglądała zatem para dwa kroki wstecz? Dzielnik musiał być równy <math>3</math>, a reszta równa <math>2</math>, więc w grę wchodzą pary <math>(5, 3), (8, 3), (11, 3),\ldots</math>. Z nich znów najoszczędniejsza jest para <math>(5, 3)</math>. Dalej, cofając się i rozumując w analogiczny sposób, dostaniemy pary <math>(8,5)</math> i kolejno <math>(13, 8), (21, 13),\ldots</math>. Widać zatem, że zawsze najoszczędniej będzie tak dobierać kolejną parę, aby wynik dzielenia był równy <math>1</math>, czyli innymi słowy, jeśli w kolejnym obrocie pętli argumenty są równe <math>a</math> i&nbsp;<math>b</math>, to w poprzednim powinny być równe <math>a + b</math> i&nbsp;<math>a</math>. Wtedy bowiem <math>b</math> jest resztą z dzielenia <math>a + b</math> przez <math>a</math>, natomiast iloraz równy jest&nbsp;1. 

Zbadajmy zatem, jakie najmniejsze argumenty dają zadaną liczbę obrotów pętli. 

<table align="center" class="standard-table" border="1" cellspacing="2" cellpading="3">
<tr>
<th> Liczba obrotów </th>
<th>&nbsp; a&nbsp;   </th>
<th>&nbsp;   b&nbsp;   </th>
</tr>
<tr><td align="center">
0<br>
1<br>
2<br>
3<br>
4<br>
5<br>
6<br>
...</td>
<td align="center">
1<br>
1<br>
3<br>
5<br>
8<br>
13<br>
21<br>
&nbsp;</td>
<td align="center">
0<br>
1<br>
2<br>
3<br>
5<br>
8<br>
13<br>
&nbsp;</td>
</tr></table>


Liczby, które występują w tabeli, są znane pod nazwą '''liczb Fibonacciego'''. Mają one w informatyce duże znaczenie i warto znać podstawowe fakty o nich. Definiuje się je następująco: 

'''Liczby Fibonacciego'''
 <math>F_{0}=0</math>
 <math>F_{1}=1</math>
 <math>F_n = F_{n-1}+F_{n-2}</math> dla <math>n \ge 2</math>

Każda kolejna liczba Fibonacciego jest sumą dwóch swoich poprzedniczek. Parę początkowych wyrazów tego ciągu warto znać na pamięć.

<table align="center" class="standard-table" border="1" cellspacing="2" cellpading="3">
<tr>
<th>&nbsp;&nbsp; <math>n</math> &nbsp;&nbsp; </th>
<th>&nbsp;&nbsp; <math>F_{n}</math> &nbsp;&nbsp;   </th>
</tr>
<tr><td align="center">
0<br>
1<br>
2<br>
3<br>
4<br>
5<br>
6<br>
7<br>
8<br>
...</td>
<td align="center">
0<br>
1<br>
1<br>
2<br>
3<br>
5<br>
8<br>
13<br>
21<br>
&nbsp;</td></tr></table>

[[Image:binet.jpg||thumb|right|200px|Jacques Philippe Marie Binet (1786-1856)]]
Widzimy więc, że poczynając od drugiego wiersza tabeli (<math>n\ge 1</math>), najbardziej złośliwych danych dla algorytmu Euklides2 mamy zawsze <math>a = F_{n+2}, b= F_{n+1}</math>. Aby wymusić <math>n</math> obrotów pętli musimy wziąć zatem co najmniej <math>n + 2</math>-gą i <math>n + 1</math>-wszą liczbę Fibonacciego. 
[[Image:euler.jpg||thumb|right|200px|Leonhard Euler (1707-1783)]]
Liczby Fibonacciego rosną szybko. Konkretnie znany jest ogólny wzór na <math>n</math>-tą liczbę Fibonacciego przypisywany Binetowi, a znany jeszcze na pewno Eulerowi 100 lat przed Binetem.

 
<span id="WzorEulera-Bineta"/> 
<center><math>F_n=\frac{1}{\sqrt{5}}((\frac{1+\sqrt{5}}{2})^n-(\frac{1-\sqrt{5}}{2})^n)
</math></center>

Dowód tego wzoru można znaleźć w [[#MatematykaDyskretna-xxx]]. 

Wprowadzając oznaczenia <math>\varphi = \frac{1+\sqrt{5}}{2}, \hat{\varphi} = \frac{1-\sqrt{5}}{2}</math>, otrzymujemy wzór w nieco bardziej czytelnej postaci

<center><math>F_n=\frac{1}{\sqrt{5}}(\varphi^n-\hat{\varphi}^n)</math>.</center> 

Biorąc pod uwagę to, że <math>\varphi = 1,618...</math>, zaś <math>\hat{\varphi} = -0,618...</math> i to, że w związku z tym składnik <math>\hat{\varphi}^{n}</math> w naszym wzorze bardzo szybko dąży do zera, możemy łatwo pokazać, że n-ta liczba Fibonacciego jest równa 

<span id="KrotkiFibo"/> 
<center><math>F_n=[\frac{1}{\sqrt{5}}\varphi^n]</math>,&nbsp;&nbsp;&nbsp;(&#8727;)</center>

gdzie przez <math>[x]</math> oznaczamy zaokrąglenie <math>x</math>, czyli liczbę całkowitą najbliższą danej liczby rzeczywistej <math>x</math>. Zatem n-ta liczba Fibonacciego jest prawie dokładnie równa n-tej potędze <math>\varphi</math> podzielonej przez <math>{\sqrt{5}}</math>. Zauważmy jeszcze, że skoro tak, to po zlogarytmowaniu obustronnie wzoru [[#KrotkiFibo|(&#8727;)]] przy podstawie <math>\varphi</math> otrzymujemy wzór 

<center><math>\log_{\varphi} F_n = n -  log_{\varphi}\sqrt{5}</math>.</center> 

Zatem indeks <math>n</math> zadanej liczby Fibonacciego <math>F_{n}</math> wynosi 

<center><math>n=\log_{\varphi}F_n  +  log_{\varphi}\sqrt{5}</math>.</center>

Zapamiętajmy sobie niezwykle ważny wniosek:

{{wniosek|||Liczby Fibonacciego rosną wykładniczo szybko. Ich wzrost jest prawie identyczny, jak funkcji wykładniczej <math>\frac{1}{\sqrt{5}} \varphi^n</math>.}} 

Wprowadźmy oznaczenie <math>\text{FIB}(a)</math> na największą liczbę Fibonacciego mniejszą od <math>a</math>, a przez <math>[n]\text{FIB}(a)</math> jej indeks. Ponieważ dla dowolnych argumentów <math>(a, b)</math> liczba obrotów pętli algorytmu Euklides2 nie przekracza liczby obrotów pętli dla argumentów najbardziej złośliwych, czyli <math>\text{FIB}(a)=F_{[n]\text{FIB}(a)}</math> oraz poprzedniej liczby Fibonacciego <math>F_{[n]\text{FIB}(a)-1}</math>, a liczba obrotów pętli dla tych argumentów jest o <math>2</math> mniejsza, niż indeks większej z nich, to otrzymujemy szacowanie na liczbę obrotów pętli <math>M(a, b)</math> dla dowolnych argumentów <math>a</math> i <math>b</math>:

<span id="KrotkiFibo2"/> 
<center><math>
M(a,b) \le M(\text{FIB}(a)), \text{FIB}(\text{FIB}(a)) = [n]\text{FIB}(a)-2</math> </center>

skąd

<center><math>M(a, b)+ 2 \le \log_{\varphi}F_n  +  log_{\varphi}\sqrt{5}</math>,</center>

a biorąc pod uwagę, że 

<center><math>log_{\varphi}\sqrt{5}=1,67...</math></center>
otrzymujemy 

<center><math>M(a,b)\le \log_{\varphi}a \log_{\varphi}a \le log_{\varphi}(\text{FIB}(a))</math>.</center>

Zapamiętajmy jeszcze jedną ważną prawidłowość. 

{{uwaga|||
Indeksy liczb Fibonacciego rosną logarytmicznie wolno w stosunku do wartości tych liczb. 
}}

Zatem funkcja [n]FIB(x) rośnie logarytmicznie ze względu na x.

Wracając do naszych danych trzydziestocyfrowych: możemy oszacować liczbę obrotów pętli przez <math>log_{\varphi} 10^{30} = 148,33...</math>. Zatem wykonamy nie więcej niż 150 obrotów pętli, co oczywiście będzie w zasięgu nawet bardzo wolnego komputera. Pamiętajmy, że przy dużych liczbach możemy zapomnieć o wbudowanych w języki programowania procedurach arytmetycznych. O arytmetykę musimy zadbać sami. Własną arytmetyką dużych liczb zajmiemy się później.

Zauważmy pewną niedogodność. W algorytmie Euklides2 jeden krok pętli jest nieco trudniejszy. W poprzednim algorytmie Euklides1 mieliśmy tylko porównywanie liczb i ich odejmowanie. Tutaj musimy zaprogramować dzielenie z resztą. Jest to nie tylko trudniejsze, ale i ogólnie wolniejsze od odejmowania. Jeśli zdecydujemy się na algorytm szkolny dzielenia słupkowego, to trzeba będzie wykonać całą serię obliczeń realizujących kolejne kroki wyznaczania cyfr ilorazu. Każdy z tych kroków wymaga wyznaczenia stosownej cyfry wyniku, przemnożenia jej wartości przez dzielnik, a następnie odjęcia od fragmentu dzielnej tego wyniku. Robimy to z grubsza tyle razy, ile cyfr ma iloraz. 

Jeżeli za miarę wielkości liczby przyjmiemy długość jej reprezentacji w systemie pozycyjnym (czyli liczbę cyfr), to o ile porównywanie oraz odejmowanie można zrobić w czasie proporcjonalnym do długości tej reprezentacji, to dzielenie może wymagać kwadratowego czasu. Niech długość dzielnej wynosi <math>n</math>. Zauważmy, że jeśli dzielnik jest o połowę krótszy od dzielnej, (czyli mając długość <math>n/2</math> jest mniej więcej równy pierwiastkowi kwadratowemu z dzielnej), to iloraz będzie miał długość podobną jak dzielnik, czyli <math>n/2</math> i tyle razy będzie się musiała wykonać zasadnicza  pętla algorytmu dzielącego, bo tyle cyfr trzeba wyznaczyć. Z kolei wyznaczenie każdej cyfry ilorazu wymaga odjęcia jakiejś niewielkiej wielokrotności dzielnika, a więc liczby również z grubsza <math>n/2</math>-cyfrowej. A odejmowanie jest proporcjonalnie kosztowne do długości argumentów. Łącznie zatem <math>n/2</math> cyfr ilorazu razy <math>n/2</math> jednocyfrowych kroków przy odejmowaniu daje nam łącznie <math>n^2/4</math>, więc kwadratowo wiele w stosunku do <math>n</math>. 

Liczba obrotów głównej pętli algorytmu jest też proporcjonalna do <math>n</math>, bo w dowolnym systemie pozycyjnym liczba cyfr jest proporcjonalna do logarytmu z danej liczby przy podstawie będącej bazą systemu, czyli również proporcjonalna do logarytmu przy podstawie <math>\varphi</math>, bo logarytmy o różnych podstawach różnią się od siebie tylko o czynnik stały. 

Jeśli skupimy się na operacjach na pojedynczych cyfrach, to łączna liczba wszystkich operacji będzie rzędu co najwyżej <math>n^3</math>. W rzeczywistości możemy się pokusić o przypuszczenie, że będzie to nawet mniej. Zauważmy bowiem, że złośliwe dane dla głównej pętli, to kolejne liczby Fibonacciego, a te długością różnią się co najwyżej o 1, natomiast złośliwe dane dla algorytmu dzielenia z resztą, to dane różniące się długością dwukrotnie; liczby Fibonacciego można podzielić w czasie liniowym, a nie kwadratowym. I to liczby Fibonacciego będą się pojawiały cały czas, w każdym kroku algorytmu. Jeżeli zatem zaczniemy od pary kolejnych liczb Fibonacciego, to <math>O(n)</math>-krotnie wykonamy dzielenie kosztujące <math>O(n)</math>, co nam da <math>O(n^{2})</math>. Jeśli natomiast będziemy się starali wywindować koszt dzielenia, to długości kolejnych par powinny być równe <math>(n,n/2), (n/2,n/4 ), (n/4, n/8),\ldots</math>. Ale wtedy łączny koszt dzieleń będzie równy 

<center><math>\frac{n^2}{4}+\frac{n^2}{16}+ \frac{n^2}{64}+\ldots =O(n^2)</math>.</center> 

Zatem obie skrajności: złośliwe dane dla zewnętrznej i dla wewnętrznej pętli dają koszt kwadratowy. Ale czy nie można wypośrodkować złośliwości tak, aby uzyskać jednak złożoność sześcienną? 

{{cwiczenie|||
Czy można tak dobrać dane, żeby wymusić sześcienną złożoność algorytmu Euklides2? 
}}


<div class="mw-collapsible mw-made=collapsible mw-collapsed">
<span class="mw-collapsible-toogle mw-collapsible-toogle-default style="font-variant:small-caps">Odpowiedź</span>
<div class="mw-collapsible-content" style="display:none">NIE. Złożoność algorytmu Euklides2 jest jednak kwadratowa. 
</div>
</div>


Powstaje pytanie, czy nie dałoby się znaleźć takiego algorytmu znajdowania największego wspólnego dzielnika tak, aby zachowując złożoność kwadratową korzystać z łatwiejszych operacji niż dzielenia z resztą. Rozwiązanie jest zaskakująco proste, jeśli zauważymy parę dość oczywistych faktów. Będziemy rozważać parzystość argumentów i redukować problem ze względu na tę właśnie własność. Oznaczmy zbiór liczb parzystych przez <math>P</math>. Kluczem do algorytmu jest spostrzeżenie, że jeśli jedna liczba jest parzysta, a druga nie, to największy wspólny dzielnik nie zmieni się, jeśli parzysty argument podzielimy przez 2.
 
===Euklides3===
<center><math>	(a,b) = \begin{cases} a & \mbox{jeśli }b=0 \\ 2(\frac{a}{2},\frac{b}{2}) & \mbox{jeśli }a,b\in P \\ (\frac{a}{2},b) & \mbox{jeśli }a\in P, b\notin P \\ (a,\frac{b}{2}) & \mbox{jeśli }a\notin P, b\in P\\ (a-b,b) & \mbox{jeśli }a,b\notin P \end{cases}</math></center>

Oczywiście, podobnie jak poprzednio, dbamy zawsze o to, żeby pierwszy argument nie był mniejszy od drugiego i w razie czego zamieniamy je miejscami. 

'''Euklides 3'''
{{kotwica|kod_zrodlowy|}}

 '''Read'''(a,b);       //Wczytujemy a i b, zakładając że użytkownik wie, że a>=b, a+b>0 
 wynik:=1;
 '''while''' b > 0 '''do''' 
 '''begin'''
   '''if''' a< b '''then''' zamień(a,b); //po wykonaniu tej instrukcji zawsze a>=b
   '''if''' parzyste(a) '''and''' parzyste(b) '''then''' 
          '''begin'''
              wynik:=wynik*2
              a:=a div 2;
              b:=b div 2
          '''end'''
   '''else''' // w przeciwnym razie
   '''if''' parzyste(a) '''and''' '''not''' parzyste(b) '''then''' a:=a div 2 '''else''' 
   '''if''' '''not''' parzyste(a) '''and''' parzyste(b) '''then''' b:=b div 2 '''else'''
   a:=a-b
 '''end''';
 wynik:=wynik*a;
 Write(a)


W kodzie tym posługujemy się predykatem <tt>parzyste(x)</tt>, który przyjmuje wartość <tt>true</tt> (prawda), jeśli x jest parzyste i <tt>false</tt> (fałsz) jeśli jest nieparzyste. Operacja <tt>div</tt> daje nam wynik dzielenia całkowitego (z ucięciem reszty). 

Przyjrzyjmy się naszemu algorytmowi pod kątem liczby obrotów pętli. Zauważmy, że w każdym obrocie we wszystkich przypadkach, poza sytuacją obu argumentów nieparzystych, co najmniej jeden z argumentów jest połowiony. Natomiast w przypadku obu argumentów nieparzystych jeden z argumentów stanie się parzysty w wyniku odejmowania i w następnym obrocie pętli zostanie podzielony przez 2. Zatem co najmniej raz na dwa obroty pętli, co najmniej jeden z argumentów jest dzielony przez 2. Ale dzieleń przez 2 można wykonać tylko logarytmicznie dużo. 

{{uwaga|||W dziedzinie całkowitoliczbowej możemy spojrzeć na logarytm jak na liczbę możliwych dzieleń przez 2, zanim dojdziemy do jedynki. Liczba ta jest równa podłodze z logarytmu rzeczywistego przy podstawie 2. }}

Zatem łączna liczba obrotów pętli nie przekracza <math>2(\log_2a + \log_2b)</math>. Co się dzieje w każdym obrocie pętli? Każda z operacji ma złożoność liniową. Sprawdzenie parzystości liczby wymaga zajrzenia do ostatniej cyfry. Sprawdzenie, czy liczba jest równa zero wymaga przejrzenia w najgorszym razie wszystkich jej cyfr jednokrotnie. Dzielenie przez 2 i mnożenie przez dwa, podobnie jak odejmowanie, mają złożoność liniową (czyli proporcjonalną do logarytmu z wartości a i b). Zatem złożoność algorytmu na poziomie operacji na cyfrach jest kwadratowa, czyli w tym przypadku proporcjonalna do kwadratu z logarytmu <math>a</math>.

==Dziedzina algorytmiczna==

Ważnym pojęciem przy określaniu algorytmu jest pojęcie dziedziny algorytmicznej. Algorytmy wykonują pewne operacje na argumentach i wyrażenie własności algorytmu, a w tym określenie jego złożoności, dokonywane jest za pomocą tych operacji. Dziedziną algorytmiczną nazwiemy zatem system relacyjny <math>\langle A,\{o_i\}_{i\in I}, \{r_{j}\}_{j\in J}\rangle</math>, gdzie <math>A</math> nazywany jest nośnikiem, a zbiory <math>\{o_i\}_{i\in I}, \{r_{j}\}_{j\in J}</math>, odpowiednio zbiorem operacji i relacji określonych w <math>A</math>, których można używać w algorytmie. Zauważmy, że od tego, jakimi operacjami i relacjami dysponujemy zależą nasze możliwości opisywania algorytmów. Zawsze musimy wiedzieć, z jakich operacji można korzystać, zanim zabierzemy się za programowanie. Czasami takie operacje przyjmują postać bibliotek gotowych procedur i funkcji – cegiełek, z których składamy nasze algorytmy.  

W przypadku naszych trzech algorytmów Euklidesa te trzy dziedziny, to: 
#Euklides1: <math>\langle {\cal N}, -,\le, =_0 \rangle</math>
#Euklides2: <math>\langle  {\cal N}, \bmod, =_0 \rangle</math>
#Euklides3: <math>\langle  {\cal N}, -,\div_2, *_2,\le, \in_P,=_0 \rangle</math>,
gdzie <math>-</math>, to zwykłe odejmowanie, mod operacja znajdowania reszty, <math>\div_2</math> - jednoargumentowa operacja dzielenia przez 2, <math>*_2</math> jednoargumentowa operacja mnożenia przez 2 (zauważmy, że przez nic innego nie musimy dzielić ani mnożyć), <math>\le</math> relacja dwuargumentowa niemniejszości, <math>\in_P</math> jednoargumentowa relacja parzystości, zaś <math>=_0</math> relacja jednoargumentowa bycia zerem. 

Uświadomienie sobie, w jakiej dziedzinie algorytmicznej operujemy, jest ważne między innymi z punktu widzenia porównywania algorytmów. Łatwo jest bowiem "skrzywdzić" jakiś algorytm nie zauważając, że działa on w uboższej dziedzinie niż rzekomo lepszy, a przyjrzenie się kosztowi operacji podstawowych daje lepszy wgląd w istotę złożoności. 

Jeszcze parę słów na temat złożoności algorytmów. Jak mogliśmy to zauważyć, brak analizy złożoności może doprowadzić do porażki – algorytm, nawet poprawny, może stać się praktycznie bezużyteczny, jeśli będzie miał zbyt dużą złożoność. Dokładniej o złożoności będzie jeszcze mowa na dalszych wykładach z bardziej zaawansowanej algorytmiki. Podkreślmy parę podstawowych spraw. 

# Złożoność określamy obliczając liczbę operacji dominujących, czyli takich, które najczęściej będą wykonywane.
# Złożoność wyznacza się zazwyczaj z dokładnością do rzędu wielkości, a więc zaniedbując czynnik stały. Czasami czynnik ten bierze się pod uwagę, ale dopiero wtedy, gdy porównujemy algorytmy o podobnym rzędzie złożoności. Najczęściej do określenia złożoności używa się notacji <math>O</math>, która pozwala uwolnić się od czynnika stałego i skupia się właśnie na rzędzie wielkości. [[#MatematykaDyskretna.xxx]] <br><br><span style="font-variant:small-caps">Definicja [Definicja notacji <math>O</math>]</span><br>Mówimy, że funkcja <math>f:{\cal N}  \rightarrow R</math> jest <math>O(g)</math>, jeśli istnieją stała <math>c>0</math> oraz liczba <math>m\in {\cal N}</math> takie, że dla każdego <math>n>m</math> zachodzi <math>f(n)\le cg(n)</math>.<br><br>
# Złożoność zależy od rozmiaru danych. Przez rozmiar danych najczęściej rozumiemy liczbę bitów (czy bajtów) potrzebnych do zakodowania danych; znowu chodzi o rząd wielkości. Na przykład jeśli mówimy o sortowaniu liczb, to ważne jest ile ich jest, a nie to, z jaką dokładnością je podajemy – zwiększenie takiej dokładności w końcu rozmiar danych powiększy o stały czynnik. Stąd na przykład
## gdy sortujemy n obiektów, rozmiarem danych jest n;
## gdy rozważamy graf, rozmiarem danych jest suma liczby krawędzi i wierzchołków (czasem rozważamy osobno liczbę krawędzi i wierzchołków);
## gdy rozważamy algorytmy liczbowe – tak jak w naszych przykładach obliczania największego wspólnego dzielnika – rozmiarem danych jest długość zapisu cyfrowego liczby, bo tak złożone jest podanie jej wartości
# Czasami do wykonania algorytmu potrzeba dodatkowej pamięci na pomocnicze struktury. Wtedy również zastanawiamy się, ile tej pamięci potrzeba i wynik nazywamy ''złożonością pamięciową''
# Dla różnych danych algorytm może różnie się wykonywać. W praktyce rozważa się dwa rodzaje danych: pesymistyczne (czyli najbardziej złośliwe) i losowe, czyli typowe. Mówimy wtedy odpowiednio o ''złożoności pesymistycznej'' i ''złożoności średniej''.
Dobrzy informatycy wyrabiają sobie przy programowaniu nawyk myślenia o złożoności.