Algorytmy i Struktury Danych.

Transkrypt

Algorytmy i Struktury Danych. - Metoda ``Dziel i zwyciezaj``. Problem

Algorytmy i Struktury Danych.
Metoda “Dziel i zwycieżaj”.
˛
Problem Sortowania, cd.
Bożena Woźna-Szcześniak
[email protected]
Jan Długosz University, Poland
Wykład 2
Bożena Woźna-Szcześniak (AJD)
Wykład 2
1 / 47
Metoda “dziel i zwycieżaj”
˛
Idea
Metoda dziel i zwycieżaj
˛
(ang. divide and conquer) jest metoda˛
projektowania algorytmów, w której dany problem jest dzielony na
kilka mniejszych podproblemów podobnych do poczatkowego
˛
problemu.
Problemy te sa˛ rozwiazywane
˛
rekurencyjnie, a nastepnie
˛
rozwiazania
˛
wszystkich podproblemów sa˛ łaczone
˛
w celu
utworzenia rozwiazania
˛
całego problemu.
Wykład 2
2 / 47
˛
W podejściu dziel i zwycieżaj
˛
każdy poziom rekursji składa sie˛ z
nastepuj
˛ acych
˛
trzech etapów:
Dziel: Dzielimy problem na podproblemy.
Wykład 2
3 / 47
˛
˛
nastepuj
˛ acych
˛
trzech etapów:
Zwycieżaj:
˛
Rozwiazujemy
˛
podproblemy rekurencyjnie, chyba że
sa˛ one małego rozmiaru i już nie wymagaja˛ zastosowania rekursji
- używamy wtedy bezpośrednich metod.
Wykład 2
3 / 47
˛
˛
nastepuj
˛ acych
˛
trzech etapów:
Zwycieżaj:
˛
Rozwiazujemy
˛
podproblemy rekurencyjnie, chyba że
sa˛ one małego rozmiaru i już nie wymagaja˛ zastosowania rekursji
- używamy wtedy bezpośrednich metod.
Połacz:
˛
Łaczymy
˛
rozwiazania
˛
podproblemów, aby otrzymać
rozwiazanie
˛
całego problemu.
Wykład 2
3 / 47
Dziel i Zwycieżaj
˛
- przykłady zastosowań
Znajdowanie najwiekszego
˛
i najmniejszego elementu zbioru.
Wyszukiwanie binarne
Potegowanie
˛
liczb
Sortowanie szybkie
Sortowanie przez scalanie
Wykład 2
4 / 47
Element minimalny i maksymalny zbioru
Definicja problemu:
Dane:
n - liczba elementów zbioru
a1 , a2 , a3 , . . . , an - ciag
˛ elementów
Szukane: Elementy najwiekszy
˛
i najmniejszy zbioru.
Wykład 2
5 / 47
Require: tablica A o rozmiarze n {A=[0,. . . ,n-1]}
Algorytm: MIN
1: min = 0;
2: for all i = 1 to n do
3:
if A[i] < A[min] then
4:
min = i;
5:
end if
6:
i = i + 1;
7: end for
8: return min;
Algorytm: MAX
1: max = 0;
2: for all i = 1 to n do
3:
if A[i] > A[max] then
4:
max = i;
5:
end if
6:
i = i + 1;
7: end for
8: return max;
Naiwne rozwiazanie
˛
problemu:
Najpierw wyszukujemy
element najwiekszy
˛
metoda˛
bezpośrednia,
˛ a potem
element najmniejszy.
Złożoność obliczeniowa: O(n)
Algorytm MAX : n - 1
operacji porównania
Algorytm MIN : n - 1 operacji
porównania
Razem MAX i MIN : 2n - 2
operacji porównania
Przykład: 2 5 3 1 8 9 1 5 4 - 16
porównań
Wykład 2
6 / 47
Można spróbować usprawnić rozwiazanie
˛
naiwne, znajdujac
˛
najpierw kandydatów na Min i Max.
Takie wyszukanie realizowane jest poprzez porównywanie
elementów parami.
Nastepnie
˛
stosowany jest algorytm MIN, a potem Max (lub
odwrotnie), na odpowiednim zbiorze kandydatów.
Wykład 2
7 / 47
Przykład:
Zbiór wejściowy: 2, 5, 3, 1, 8, 9, 1, 5, 4
Wykład 2
8 / 47
Przykład:
Zbiór wejściowy: 2, 5, 3, 1, 8, 9, 1, 5, 4
Porównywanie parami: 2 < 5, 3 < 1, 8 < 9, 1 < 5, 4
Wykład 2
8 / 47
Przykład:
Zbiór wejściowy: 2, 5, 3, 1, 8, 9, 1, 5, 4
Kandydaci na MIN: 2, 1, 8, 1, 4.
Wykład 2
8 / 47
Przykład:
Zbiór wejściowy: 2, 5, 3, 1, 8, 9, 1, 5, 4
Na tym zbiorze stosowany jest algorytm MIN.
Wykład 2
8 / 47
Przykład:
Zbiór wejściowy: 2, 5, 3, 1, 8, 9, 1, 5, 4
Kandydaci na MAX: 5, 3, 9, 5, 4.
Wykład 2
8 / 47
Przykład:
Zbiór wejściowy: 2, 5, 3, 1, 8, 9, 1, 5, 4
Na tym zbiorze stosowany jest algorytm MAX.
Wykład 2
8 / 47
Przykład:
Zbiór wejściowy: 2, 5, 3, 1, 8, 9, 1, 5, 4
Ostatni - nieparzysty element został dodany do obu zbiorów.
Wykład 2
8 / 47
Przykład:
Zbiór wejściowy: 2, 5, 3, 1, 8, 9, 1, 5, 4
Ostatni - nieparzysty element został dodany do obu zbiorów.
Wykorzystujemy tu własność podziału mówiac
˛ a,
˛ iż w każdym
zbiorze skończonym zawsze znajduje sie˛ element najwiekszy
˛
i
element najmniejszy.
Wykład 2
8 / 47
Szacowanie:
Przy rozdzielaniu elementów wykonano 4 porównania.
Algorytm MIN na zbiorze {2, 1, 8, 1, 4} wykonał 4 porównania i
zwrócił wartość 1.
Algorytm MAX również na zbiorze {5, 3, 9, 5, 4} wykonał 4
porównania i zwrócił wartość 9.
W sumie wykonano 4 + 4 + 4 = 12 porównań, co oznacza 25%
wzrost wydajności w porównaniu z podejściem naiwnym (tam
potrzebnych było 16 porównań)!
Wykład 2
9 / 47
Require: tablica A o rozmiarze n
{A = [0, . . . , n − 1]}
Algorytm: MIN-MAX
1: min = 0; max = 0;
2: for i = 0 to n − 2 do
3:
if A[i] < A[i + 1] then
4:
if A[i] < A[min] then
5:
min = i;
6:
end if
7:
if A[i + 1] > A[max] then
8:
max = i + 1;
9:
end if
10:
else
11:
if A[i + 1] < A[min] then
12:
min = i + 1;
13:
end if
14:
if A[i] > A[max] then
15:
max = i;
16:
end if
17:
end if
18:
i = i + 2;
19: end for
20: if n is odd then
21:
if A[n − 1] < A[min] then
22:
min = n − 1;
23:
end if
24:
if A[n − 1] > A[max] then
25:
max = n − 1;
26:
end if
27: end if
28: return A[min] and A[max];
Wykład 2
10 / 47
Wyszukiwanie binarne pozwala na szybkie wyszukiwanie wartości w
posortowanych zbiorach (np. tablicy). Skuteczność wyszukiwania
binarnego wynika z tego, że zamiast przegladać
˛
wszystkie elementy
posortowanego zbioru po kolei, wykorzystujemy informacje˛ o tym, że
jest on uporzadkowany.
˛
Wykład 2
11 / 47
˛
wszystkie elementy
˛
Algorytm:
Dana jest tablica A oraz poszukiwany element key.
Sprawdź środkowy element tablicy. Jeśli jest równy key, to koniec.
Wykład 2
11 / 47
˛
wszystkie elementy
˛
Algorytm:
Jeśli środkowy element jest wiekszy
˛
niż key, to poszukiwany
element jeśli jest w tablicy, to jest w jej lewej cz˛eści.
Wykład 2
11 / 47
˛
wszystkie elementy
˛
Algorytm:
Jeśli środkowy element jest wiekszy
˛
niż key, to poszukiwany
element jeśli jest w tablicy, to jest w jej lewej cz˛eści.
Jeśli środkowy element jest mniejszy niż key, to poszukiwany
element jeśli jest w tablicy, to jest w jej prawej cz˛eści.
Wykład 2
11 / 47
Wyszukiwanie binarne - przykład
Znaleźć liczbe˛ 9 w ciagu:
˛
3, 5, 7, 8, 9, 12, 15 .
Wykład 2
12 / 47
Twierdzenie 1– Cormen T.H., Leiserson Ch.E., Rivest
R.L. Wprowadzenie do algorytmów, Roz. 4 (str. 73)
T (n) = a ∗ T (n/b) + f (n)
n - rozmiar problemu; rozmiar danych wejściowych.
a - liczba podproblemów w rekurencji.
n/b - rozmiar każdego podproblemu; w zasadzie zakłada sie,
˛ że
wszystkie podproblemy sa˛ tego samego rozmiaru.
f(n) - koszt operacji poza rekurencyjnym wywołaniem zawierajacy
˛
koszt podziału probelmu na podproblemy i koszt operacji scalenia
rozwiaza
˛ ń.
Wykład 2
13 / 47
Twierdzenie 1– Cormen T.H., Leiserson Ch.E., Rivest
R.L. Wprowadzenie do algorytmów, Roz. 4 (str. 73)
T (n) = a ∗ T (n/b) + f (n)
n - rozmiar problemu; rozmiar danych wejściowych.
a - liczba podproblemów w rekurencji.
n/b - rozmiar każdego podproblemu; w zasadzie zakłada sie,
˛ że
wszystkie podproblemy sa˛ tego samego rozmiaru.
f(n) - koszt operacji poza rekurencyjnym wywołaniem zawierajacy
˛
koszt podziału probelmu na podproblemy i koszt operacji scalenia
rozwiaza
˛ ń.
A. f (n) = O(nlogb (a)−ǫ ) implikuje, że
T (n) = Θ(nlogb (a) ) dla pewnego ǫ > 0
B. f (n) = Θ(nlogb (a) log2k (n)) implikuje, że
T (n) = Θ(nlogb (a) ∗ log2k +1 (n)) dla pewnego k ≥ 0.
Wykład 2
13 / 47
Wyszukiwanie binarne - złożoność
nlogb (a) = nlog2 (1) = n0 = 1 ⇒ (Przypadek2)
T (n) = Θ(log2 (n))
Wykład 2
14 / 47
Wyszukiwanie binarne - Koszt algorytmu
Złożoność pesymistyczna:
Operacja dominujaca:
˛
porównywanie elementów.
Koszt: T (n) = O(log2 (n))
Złożoność optymistyczna:
˛
Koszt: T (n) = O(log2 (n)).
Złożoność pamieciowa:
˛
O(1).
Wykład 2
15 / 47
Wyszukiwanie binarne - implementacja
i n t binSearch ( i n t a [ ] , i n t n , i n t key )
{
i n t l e f t = 0 , r i g h t = n − 1;
w h i l e ( l e f t <= r i g h t ) {
i n t curr = ( l e f t + r i g h t ) / 2;
i f ( key == a [ c u r r ] ) {
return curr ;
} e l s e i f ( key < a [ c u r r ] ) {
r i g h t = curr − 1;
} else {
l e f t = curr + 1;
}
}
r e t u r n ( −1);
}
Wykład 2
16 / 47
Uwagi o przeszukiwaniu liniowym i binarnym
Niech n=20 000
Algorytm wyszukiwania liniowego – czyli przegladaj
˛ acy
˛ cała˛
tablice˛ element po elemencie – wykona 20 000 porównań.
Algorytm przeszukiwania binarnego wykona tylko
log2 (20000) = 14 porównań.
Algorytm wyszukiwania binarnego wymaga jednak przekazania
posortowanych danych.
Wykład 2
17 / 47
Potegowanie
˛
liczby
Problem: Oblicz an , dla n ∈ N.
Algorytm naiwny: an = |a · a {z
· . . . · a}
n
Złożoność: Θ(n)
Algorytm dziel i zwycieżaj:
˛
n/2 n/2
a ·a ,
gdy n jest parzyste
n
a =
an−1/2 · an−1/2 · a, gdy n jest nieparzyste
Złożoność: T (n) = T (n/2) + Θ(1) ⇒ θ(log2(n))
Wykład 2
18 / 47
Sortowanie szybkie
Algorytm sortowania szybkiego (ang. quick sort) opracowany
przez C.A.R. Hoarea w 1962.
Algorytm QuickSortjest typowym algorytmem rekurencyjnym,
pracujacym
˛
w oparciu o technik˛e dziel i zwycieżaj.
˛
Algorytm zakłada dekompozycje˛ tablicy na mniejsze podtablice,
które łatwiej jest posortować.
Najcz˛eściej stosowany algorytm sortujacy
˛ w praktyce.
Wykład 2
19 / 47
Sortowanie szybkie
Idea
Rozdzielić elementy danego ciagu
˛ na dwie cz˛eści wzgledem
˛
pewnego ustalonego elementu, tzw. elementu osiowego (ang.
pivot), tak aby na lewo od niego znajdowały sie˛ elementy
mniejsze, a na prawo elementy wieksze.
˛
xx
xx
!! xx
Conquer:posortować
Recursively
thei na
two
subarrays.
Rekurencyjnie
elementysort
na lewo
prawo
od
elementu osiowego.
Połaczyć
˛
posortowane podtablice.
Wykład 2
20 / 47
Algorytm QuickSort -
Sortowanie szybkie - przykład
29
40
2
1
6
18
20
32
23
34
39
41
29
2
1
6
18
20
23
40
32
2
32
6
2
2010-02-16
39
41
40
1
1
34
6
18
18
20
20
34
39
41
23
23
29
32
34
39
40
41
-
51
Wykład 2
21 / 47
Sortowanie szybkie
W celu podzielenia tablicy konieczne jest wykonanie dwóch
operacji:
znalezienie elementu osiowego i podzieleniu tablicy na dwie
podtablice.
przejrzeniu tablicy w celu umieszczenia jej elementów we
właściwych podtablicach.
Wybór dobrego elementu osiowego nie jest zadaniem łatwym –
(obie podtablice powinny mieć zbliżona˛ wielkość).
Najcz˛eściej stosowane strategie wyboru elementu osiowego:
wybranie pierwszego elementu tablicy.
wybranie elementu znajdujacego
˛
sie˛ pośrodku tablicy.
Wykład 2
22 / 47
Sortowanie szybkie - procedura podziału
Require: tablica A[p..q]
1: PARTITION(A, p, q)
2: x = A[p]; {element osiowy = A[p]}
3: i = p;
4: for all j = p + 1 to q do
5:
if A[j] ≤ x then
6:
i = i + 1;
7:
zamien(A[i],A[j]);
8:
end if
9: end for
10: zamien (A[p], A[i]);
11: return i
Wykład 2
23 / 47
Sortowanie szybkie - procedura podziału, przykład
6
i
10
j
13
5
8
3
2
11
Wykład 2
24 / 47
6
i
10
j
13
5
8
3
2
11
6
i
10
→
13
j
5
8
3
2
11
Wykład 2
24 / 47
6
i
10
j
13
5
8
3
2
11
6
i
10
→
13
j
5
8
3
2
11
6
i
10
13
→
5
j
8
3
2
11
Wykład 2
24 / 47
6
i
10
j
13
5
8
3
2
11
6
i
10
→
13
j
5
8
3
2
11
6
i
10
13
→
5
j
8
3
2
11
6
→
5
i
10
j
8
3
2
11
13
Wykład 2
24 / 47
6
i
10
j
13
5
8
3
2
11
6
i
10
→
13
j
5
8
3
2
11
6
i
10
13
→
5
j
8
3
2
11
6
→
5
i
13
10
j
8
3
2
11
6
5
i
13
10
→
8
j
3
2
11
Wykład 2
24 / 47
6
5
i
13
10
8
→
3
j
2
11
Wykład 2
25 / 47
6
5
i
13
10
8
→
6
5
→
3
i
10
8
3
j
2
11
13
j
2
11
Wykład 2
25 / 47
6
5
i
13
10
8
→
6
5
→
3
i
10
6
5
3
i
10
3
j
2
11
8
13
j
2
11
8
13
→
2
j
11
Wykład 2
25 / 47
6
5
i
13
10
8
→
6
5
→
3
i
10
6
5
3
i
10
6
5
3
→
2
i
3
j
2
11
8
13
j
2
11
8
13
→
2
j
11
10
j
11
8
13
Wykład 2
25 / 47
6
5
i
13
10
8
→
6
5
→
3
i
10
6
5
3
i
10
6
5
3
→
2
i
8
6
5
3
2
i
8
3
j
2
11
8
13
j
2
11
8
13
→
2
j
11
13
10
j
11
13
10
→
11
j
Wykład 2
25 / 47
6
5
3
2
i
8
13
10
11
→
j
Wykład 2
26 / 47
6
5
2
3
5
2
i
3
8
6
i
13
8
10
13
10
11
→
j
11
Wykład 2
26 / 47
Sortowanie szybkie - algorytm
QuickSort (A, p, r)
Jeśli p = r , to koniec
Jeśli p < r , to
q = PARTITION(A, p, r).
QuickSort(A, p, q-1).
QuickSort(A, q+1, r).
Wywołanie: QuickSort(A, 1, n)
Wykład 2
27 / 47
Sortowanie szybkie - Złożoność pesymistyczna:
Najgorszy przpadek dla algorytmu sortowania szybkiego to ciag
˛
danych już uporzadkowanych
˛
w kolejności odwrotnej do pożadanej.
˛
Jeśli Split jako mediane˛
wybiera zawsze pierwszy
element, to w wyniku
rozdzielenia, jedna cz˛eść
„młodsza” bedzie
˛
pusta , a
druga „starsza” bedzie
˛
zawierała o jeden element
mniej niż w poprzednim
kroku.
Koszt Operacji rozdzielania
dla n elementowego ciagu
˛
wynosi n − 1 porównań.
T (n) = T (n − 1) + cn
T (n − 1) = T (n − 2) + c(n − 1)
T (n − 2) = T (n − 3) + c(n − 2)
..
.
T (2) = T (1) + c(2)
P
T (n) = T (1) + c ni=2 i = O(n2 )
Wykład 2
28 / 47
Sortowanie szybkie - Złożoność optymistyczna:
Podział jest zawsze perfekcyjnie zbalansowany.
Element osiowy jest zawsze po środku.
T (n) QuickSort (A, p, r)
Θ(1) Jeśli p = r , to koniec
Jeśli p < r , to
Θ(n) (1) q = PARTITION(A, p, r ).
2 · T (n/2) (2) rekurencyjnie posortuj A[p..q − 1] i A[q + 1..r ].
Wykład 2
29 / 47
Jeśli p < r , to
Θ(1)
n=1
T (n) =
2 · T (n/2) + Θ(n) n > 1
Na podstawie Twierdzenia 1 można pokazać, że powyższe równanie
rekurencyjne ma nastepuj
˛ ace
˛ rozwiazanie:
˛
Wykład 2
29 / 47
Jeśli p < r , to
Θ(1)
n=1
T (n) =
2 · T (n/2) + Θ(n) n > 1
˛ ace
˛ rozwiazanie:
˛
nlogb (a) = nlog2 (2) = n1 = n ⇒ (Przypadek2)
T (n) = Θ(n · log2 (n))
Wykład 2
29 / 47
Sortowanie szybkie - Koszt algorytmu
˛
Koszt: T (n) = O(n2 )
˛
Koszt: T (n) = Θ(n · log2 (n)).
˛
O(1).
Wykład 2
30 / 47
Sortowanie szybkie - implementacja
void quickSort ( i n t a [ ] , i n t l e f t , i n t r i g h t ) {
i f ( left < right ){
/ / podział t a b l ic y
int m = left ;
f o r ( i n t k = l e f t + 1 ; k <= r i g h t ; ++k ) {
i f ( a [ k ] < a [ l e f t ] ) swap ( a [++m] , a [ k ] ) ;
}
swap ( a [ l e f t ] , a [m ] ) ;
/ / Rekurencja
quickSort (a , l e f t , m − 1 ) ;
quickSort (a , m + 1 , r i g h t ) ;
}
}
v o i d swap ( i n t ∗ x , i n t ∗ y ) {
i n t tmp = ∗ x ; ∗ x = ∗y ; ∗y = tmp ;
}
Wykład 2
31 / 47
Jeden z pierwszych algorytmów sortowania.
Autor metody: John von Neumann
Wykład 2
32 / 47
Idea:
Dzielimy zadanie posortowania całego ciagu
˛ na dwa podzadania:
posortowania jego lewej i prawej połowy.
Wykład 2
32 / 47
Idea:
Dzielimy zadanie posortowania całego ciagu
˛ na dwa podzadania:
posortowania jego lewej i prawej połowy.
Gdy obie cześci
˛
tworza˛ już ciagi
˛ uporzadkowane,
˛
wtedy scalamy je
otrzymujac
˛ rozwiazanie.
˛
Wykład 2
32 / 47
Sortowanie przez scalanie - przykład
Wykład 2
33 / 47
Sortowanie przez scalanie - algorytm
MergeSort A[1..n]
Jeśli n = 1, to koniec
Jeśli n ≥ 2, rekurencyjnie posortuj A[1..n/2] i A[n/2+1..n].
Scal obie połowy A w jedna posortowana tablice.
˛
Wykład 2
34 / 47
Sortowanie przez scalanie - Operacja scalania
Zapamietujemy
˛
pozycje najmniejszego elementu w każdej
posortowanej połówce.
Wstawiamy najmniejszy z dwóch wskazywanych elementów do
tablicy pomocniczej.
Operacje powtarzamy dopóty, dopóki nie posortujemy wszystkich
elementów.
1 7 11 14 16
Najmniejszy nieprzetworzony: 1
8 9 12 18 20
Minimum z 1 i 8 1
Wykład 2
35 / 47
Zapamietujemy
˛
elementów.
1 7 11 14 16
1
8 9 12 18 20
Minimum z 7 i 8
7
Wykład 2
36 / 47
Zapamietujemy
˛
elementów.
1 7 11 14 16
1
8 9 12 18 20
Minimum z 11 i 8
7 8
Wykład 2
37 / 47
Zapamietujemy
˛
elementów.
1 7 11 14 16
1
8 9 12 18 20
Minimum z 11 i 9
7 8 9
Wykład 2
38 / 47
Zapamietujemy
˛
elementów.
1 7 11 14 16
1
8 9 12 18 20
Minimum z 11 i 12
7 8 9 11
Wykład 2
39 / 47
Zapamietujemy
˛
elementów.
1 7 11 14 16
1
7
8 9 12 18 20
Minimum z 14 i 12
8 9 11 12
Wykład 2
40 / 47
Zapamietujemy
˛
elementów.
1 7 11 14 16
1
7
8 9 12 18 20
Minimum z 14 i 18
8 9 11 12 14
Wykład 2
41 / 47
Zapamietujemy
˛
elementów.
1 7 11 14 16
1
7
8 9 12 18 20
Minimum z 16 i 18
8 9 11 12 14 16
Wykład 2
42 / 47
Zapamietujemy
˛
elementów.
1 7 11 14 16
7
8
9
11
8 9 12 18 20
Nieprzetworzone: 18 i 20
12
14
16
18
20
Wykład 2
43 / 47
Sortowanie przez scalanie - implementacja
MergeSort ( i n t A [ ] , i n t l e f t , i n t r i g h t )
{
i f ( right > l e f t ) {
mid = ( l e f t + r i g h t ) / 2 ;
MergeSort ( A , l e f t , mid ) ;
MergeSort ( A , mid +1 , r i g h t ) ;
merge ( A , l e f t , mid , r i g h t )
}
}
Wykład 2
44 / 47
Sortowanie przez scalanie - implementacja
v o i d merge ( T∗ a , i n t l e f t , i n t mid , i n t r i g h t )
{
i n t ∗ t = c a l l o c ( r i g h t +1 , s i z e o f ( i n t ) ) ;
i n t n = r i g h t − l e f t + 1;
i n t i = l e f t , j = mid + 1 , k = 0 ;
w h i l e ( i <= mid && j <= r i g h t ) {
i f (a[ i ] < a[ j ] )
t [ k ++] = a [ i + + ] ;
e l s e t [ k ++] = a [ j + + ] ;
}
w h i l e ( i <= mid ) { / / Dolaczanie koncowki p i e r w s z e j p o d t a b l i c y
t [ k ++] = a [ i + + ] ;
}
w h i l e ( j <= r i g h t ) { / / Dolaczanie koncowki d r u g i e j p o d t a b l i c y
t [ k ++] = a [ j + + ] ;
}
/ / Kopiowanie t a b l i c y pomocniczej
f o r ( k = 0 ; k < n ; ++k ) a [ l e f t + k ] = t [ k ] ;
free ( t )
}
Wykład 2
45 / 47
Sortowanie przez scalanie - Koszt algorytmu
T (n)
Θ(1)
2 · T (n/2)
Θ(n)
MergeSort A[1..n]
˛
Wykład 2
46 / 47
T (n)
Θ(1)
2 · T (n/2)
Θ(n)
MergeSort A[1..n]
˛
T (n) =
Θ(1)
n=1
2 · T (n/2) + Θ(n) n > 1
˛ ace
˛ rozwiazanie:
˛
Wykład 2
46 / 47
T (n)
Θ(1)
2 · T (n/2)
Θ(n)
MergeSort A[1..n]
˛
T (n) =
Θ(1)
n=1
2 · T (n/2) + Θ(n) n > 1
˛ ace
˛ rozwiazanie:
˛
nlogb (a) = nlog2 (2) = n1 = n ⇒ (Przypadek2)
T (n) = Θ(n · log2 (n))
Wykład 2
46 / 47
˛
Koszt: T (n) = Θ(n · log2 (n))
˛
Koszt: T (n) = Θ(n · log2 (n)).
˛
O(1).
Wykład 2
47 / 47

Algorytmy i Struktury Danych. - Metoda ``Dziel i zwyciezaj``. Problem

Transkrypt

Podobne dokumenty

Plakat

Samobójstwo Europy. Wielka Wojna 1914–1918

Tematy prac magisterskich 2010/ 2011

Aleksandra Gradoń (absolwentka AJD z 2012 roku) zaprasza do

Tematy Prac Magisterskich

Marta Salwierak wspomina studia w AJD (ukończyła kierunek

KURS JĘZYKA NIEMIECKIEGO W BRANŻY MEDYCZNEJ

Międzynarodową Konferencję Naukową nt: Doradztwo zawodowe