ALGORYTMY I STRUKTURY DANYCH

(1)

ALGORYTMY I STRUKTURY DANYCH

WYKŁAD 01 Wprowadzenie Grażyna Mirkowska

PJWSTK ITN, semestr letni 2002

(2)

Plan wykładu

 Organizacja wykładu i ćwiczeń z ASD.

 Cel wykładu.

Zapoznanie studentów z podstawowym zestawem algorytmów realizujących zadania typu wyszukiwanie, sortowanie, oraz z najczęściej wykorzystywanymi strukturami danych: stosami, kolejkami, słownikami, kolejkami priorytetowymi i drzewami.

Przedstawione zostaną również zasadnicze problemy algorytmiki związane z analizą poprawności i kosztu algorytmów.

 O czym będzie mowa w tym wykładzie?

(3)

O czym będzie mowa w tym wykładzie?

 Jak formułować (specyfikować) zadania i algorytmy?

 Jak porównywać algorytmy?

 Co to jest struktura danych?

 Jak weryfikować algorytm (program)?

 Czy zawsze można znaleźć lepsze rozwiązanie?

 Czy zawsze istnieje algorytm rozwiązujący dany problem?

(4)

Od problemu do jego rozwiązania

Sformułowanie zadania.

Rozwiązanie problemu.

Przykład: Dany jest ciąg liczb. Znaleźć największą z nich.

Niech max ma wartość równą pierwszemu

elementowi ciągu.

Porównaj max z kolejnymi

elementami ciągu i jeśli spotkasz

wartość większą, przyjmij ją jako nową wartość max.

(5)

Co to jest algorytm?

Algorytm to metoda postępowania, która

prowadzi do rozwiązania jakiegoś problemu.

Algorytm, to skończony ciąg etapów, które pozwalają

przekształcić dane informacje wejściowe w informacje

Al-Khowârizmî (Persja, 8-9w.n.e.)

Włącz gaz;

Zagotuj wodę;

Wsyp do szklanki kawę rozpuszczalną;

Zalej kawę wrzącą wodą;

Dosyp cukru, jeśli lubisz;

Poczekaj kilka minut;

(Euklides)

Dopóki x różne od y wykonuj:

Jeżeli x>y, to odejmij y od x i wynik podstaw na x; W przeciwnym przypadku od y odejmij x i wynik podstaw na y;

koniec dopóki wynikiem jest y

(6)

Algorytm - metoda postępowania

Funkcje rekurencyjne, Algorytmy Markova, Maszyny Turinga,

Automaty,

Wyrażenia regularne

Dane Algorytm Wyniki

Teza Churcha

Przykład dla algorytmu Euklidesa Dane x =21, y =12.

(x,y) (21,12) (9,12) (9,3) (6,3) (3,3) Wynik 3

stan pamięci przed

wykonaniem algorytmu

stan pamięci po

wykonaniu algorytmu

(7)

Jak zapisywać algorytmy?

Najczęściej formułujemy zadania i problemy w języku naturalnym ale...

Konstrukcje:

if test then {Instrukcje} else{Instrukcje} fi while test do{Instrukcje}od

begin {Instrukcja1}; {Instrukcja 2};...{Instrukcja n-ta;}

end

x := wyrażenie odpowiedniego typu;

(8)

Jak porównywać algorytmy?

• prostota

• czytelność

• długość kodu

• poprawność

• czas realizacji

• zajętość pamięci

Idealny algorytm to taki, który ma prosty kod, jest napisany w ogólnie

dostępnym języku

programowania, łatwo go zrozumieć, liczy szybko, nie wymaga dużo miejsca w pamięci i zawsze daje poprawne wyniki.

(9)

Co to jest struktura danych?

Sformułowanie problemu algorytmicznego wymaga

zwykle określenia środowiska, którego problem dotyczy.

Problem „ Znaleźć największy element w danym ciągu” wymaga określenia czym są elementy (np.. Liczbami, zbiorami,

dokumentami) i jak się je porównuje.

Algorytm, który ma realizować pewną metodę rozwiązania problemu musi znać to środowisko i móc się nim posługiwać.

Strukturą danych będziemy nazywali system relacyjny,

którego uniwersum określa wartości zmiennych i a operacje i relacje dostarczają narzędzi do realizacji algorytmu.

(10)

Przykład1

while (x y) { if x >y

then x := x – y else y := y – x fi

}

return x

Jeśli rozważymy ten algorytm w strukturze liczb całkowitych podając jako początkowe

wartości x=a i y=b, to algorytm zwróci jako wynik nwd(a,b)

Jeśli rozważymy ten algorytm w strukturze, której uniwersum składa się z odcinków na prostej, relacja > pozwala porównać długości odcinków, natomiast operacja – daje w wyniku różnicę odcinków, to algorytm

zwraca jako wynik najdłuższy odcinek, który mieści się całkowitą ilość

Czasami daje wynik!

Zawsze daje daje wynik!

(11)

Poprawność algorytmu

Intuicyjnie, poprawność = zgodność z zamierzeniami.

Specyfikacją algorytmu nazywać będziemy parę warunków

(własności)

Warunek początkowy

Warunek końcowy

< wp , wk >

Algorytm Alg działający w strukturze danych S jest częściowo

poprawny ze względu na specyfikację <wp, wk> wttw dla wszystkich danych spełniających warunek początkowy, jeżeli algorytm zatrzyma się, to uzyskane wyniki spełniają warunek końcowy.

{wp} Alg {wk}

(12)

Całkowita poprawność algorytmu

wp wp Alg Alg wk wk

Powiemy, że algorytm Alg działający w strukturze danych S jest całkowicie poprawny ze względu na specyfikację <wp,wk> wttw dla wszystkich danych w strukturze S spełniających warunek początkowy wp, algorytm zatrzymuje się i daje wyniki

spełniające warunek końcowy wk.

S |=

{wp}  Alg{wk}

(13)

Przykład 2

{ i:= 1; k := 1; x:=0;

while (i n){

x := x + k;

k := k + 2;

i := i + 1;

}

return x }

Problem: Obliczyć kwadrat liczby naturalnej n.

Specyfikacja:

warunek początkowy: n>0 warunek końcowy: x jest kwadratem liczby n.

Algorytm jest całkowicie poprawny w strukturze liczb naturalnych i jest częściowo poprawny w strukturze

(14)

Niezmiennik

{i := 1; k := 1; x :=0;

while (i n){

x := x + k;

k := k + 2;

i := i + 1;

}

return x }

k=2i-1, x = _j=1..i-1 (2j-1)

k= 2i+1

x = _j=1..i (2j-1)

x = _j=1..i-1 (2j-1), k=2i-1, i  n+1

Niezmiennikiem pętli nazywać będziemy własność

(formułę), która jeśli jest

prawdziwa na początku

wykonania pętli, to jest również prawdziwa po wykonaniu treści pętli.

(15)

Przykład 3

P: while abs(b-a)>eps { x := (a+b)/2;

if (f(a)*f(x)  0 ) then b := x

else a := x fi;

}

x

x := (a+b)/2

a := x b := x

abs(b-a)>eps

f(a)*f(x)  0

START

STOP f(a)*f(b)< 0, eps>0 , a<b

TAK NIE

Niezmiennik :f(a)*f(b) 0,

f(a)*f(b)  0, b-x = x-a

f(a)*f(x)  0 f(x)*f(b)  0 f(a)*f(b)  0

TAK NIE

(16)

Czy algorytm P zatrzymuje się?

P:{ i:= 0;

while abs(b-a)>eps { x := (a+b)/2;

if f(a)*f(x)  0 then b := x else a := x fi;

i := i+1 }}

x := (a+b)/2

a := x b := x

abs(b-a)>eps

f(a)*f(x)  0

START i:=0;

STOP

TAK NIE

b-a= w/2ⁱ> eps

b-x = x-a = w/2 ⁱ⁺¹

x - a = w/2 ⁱ⁺¹ b- x = w/2 ⁱ⁺¹ b-a= w/2ⁱ

TAK NIE

i:= i+1

x

Dla i = lg (w/eps) mamy b-a  eps.

(17)

Koszt algorytmu

Miary kosztu:

• Liczba instrukcji

• liczba operacji arytmetycznych

• liczba wywołań procedury

• Liczba zmiennych

• ilość miejsca potrzebna dla danych

Ogólnie: wybór miary zależy od typu problemu, rodzaju rozwiązania.

(18)

Przykłady

Mnożenie macierzy

Wyszukiwanie elementu w tablicy Sortowanie

Mając dany algorytm, konkretne środowisko i konkretne dane możemy policzyć liczbę operacji dominujących.

Operacje + , *

porównywanie

Koszt algorytmu dla danych d:

algorytm

(19)

Złożoność czasowa algorytmu

Definicja Złożoność czasowa to liczba operacji dominujących (podstawowych) wykonanych przez algorytm w czasie jego realizacji, wyrażona jako funkcja rozmiaru danych.

Niech D_n będzie zbiorem danych rozmiaru n dla pewnego problemu P oraz A algorytmem rozwiązującym problem P.

W(Alg,n) = sup {t(Alg,d) : d D_n}

A(Alg,n) = { p(d) * t(Alg,d) : d D }

Uwaga1.Faktyczny czas wykonania algorytmu jest proporcjonalny do

złożoności czasowej.

Uwaga2 Czas wykonania algorytmu jest bardziej

(20)

Notacja asymptotyczna

Niech f , g : N  R+.

Powiemy, że g jest co najwyżej rzędu f

wttw (c>0)(noN)(n>no) g(n)  c f(n).

Powiemy, że g jest co najmniej rzędu f

wttw (c>0)(noN)(n>no) c*f(n)  g(n).

g = g =   (f ) (f ) g = O (f ) g = O (f )

g = g =   (f ) (f )

Powiemy, że rzędy funkcji f i g są takie same, wttw g= O(f) i f = O(g).

(21)

Porównywanie rzędów funkcji

Przykład 1 Niech f(n)=100n, g(n)= 2n+100, h(n) = 0.1 n² +n.

Mamy f = O(n) f = (n) g= O(n²) g = (n) h = O(n²) = O(n³ ) h O(n) h =  (n)

Lemat (O porównywaniu rzędów funkcji) Niech lim _n f(n)/g(n) = c. Wtedy

1. Jeżeli c  0 to f i g są tego samego rzędu.

2. Jeżeli c= 0, to f = O(g) oraz f   (g).

3. Jeżeli c=+ , to f ma rząd większy niż g, g = O(f) i g  (f).

Przykład 2

f(n) = 0.3 n³ + 10n + 100 g(n)= n³

h(n) = log n

lim _n f(n)/g(n)= 0.3 Czyli f = (g)

lim f(n)/h(n) = + 

(22)

Porównanie szybkości wzrostu funkcji

Powiemy, że algorytm Alg ma złożoność czasową wielomianową wttw T(Alg,n)= (n ^)  N wykładniczą wttw T(Alg,n) = (a ⁿ) a  R+

liniową wttw T(Alg,n)= (n) kwadratową wttw T(Alg,n)= (n ²) logarytmiczną wttw T(Alg,n)= (lg n)

lg n! = _i=1..n lg i  n lg n lg n

n cn

x x x

e xdx

x

n ⁿ

n n

lg )

ln ( ln lg

lg

!

lg ¹

1 1











^



^ ^

(23)

f(n)= log n f(n)=n

f(n) = 2ⁿ

f(n) =0.25 n²

Porównanie szybkości wzrostu funkcji

(24)

Złożoność a rozmiar i czas

Jaki jest maksymalny rozmiar problemu, który można rozwiązać w ustalonym czasie, znając złożoność algorytmu?

Ile czasu potrzeba na rozwiązanie zadania o ustalonym rozmiarze i złożoności?

1s

n³

lg n n n lg n n² 2ⁿ

10²

2 ^1000000 10⁶ 63*10³ 10³ 19

T(A,n) czas

n=10² n= 10⁴

n³

lg n n n lg n n² 2ⁿ

1s 1dni 6.6s

13.3 s

0.6ms

0.1ms 10ms 10⁶lat

10ms 0.1s 100s 10¹⁰⁰ l

T(A,n) wymiar

(25)

Komputer 1 Komputer 2

n³

lg n n n² 2ⁿ

s4 2*s4 s1

s1 ¹⁰

s2 s3 s5

10*s2 10*s3 ?

Czy szybkość może pokonać złożoność?

Mamy 5 algorytmów A1, A2, A3, A4, A5 rozwiązujących ten sam

problem. Niech s_i oznacza maksymalny rozmiar problemu, który można rozwiązać na komputerze 1 przy pomocy algorytmu A_i w ustalonym

czasie t. Jaki jest maksymalny rozmiar problemu, który można rozwiązać w tym samym czasie t na komputerze 10 razy szybszym?

Przykład A5. Dla komputera 1: T(A5,s5)=2 ^s5 = t . Dla komputera 2 : T(A5,s5)= 2 ^s5 = t /10.

Szukamy takiego x, że T(A5,x)= t.