Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

Sortowanie: kopce 16 1 14 2 10 3 8 4 7 5 9 6 3 7 2 8 4 9 1 1614108 1 2 3 4 5 6 7 8 9 10 8793241 Parent(i) return i/2 Left(i) return 2i Right(i) return.

Podobne prezentacje


Prezentacja na temat: "Sortowanie: kopce 16 1 14 2 10 3 8 4 7 5 9 6 3 7 2 8 4 9 1 1614108 1 2 3 4 5 6 7 8 9 10 8793241 Parent(i) return i/2 Left(i) return 2i Right(i) return."— Zapis prezentacji:

1 Sortowanie: kopce Parent(i) return i/2 Left(i) return 2i Right(i) return 2i+1 Własność kopca: dla każdego węzła i, który nie jest korzeniem: A[Parent(i)]  A[i]

2 Przywracanie własności kopca Zakładamy, że drzewa binarne zaczepione w Left(i) i Right(i) są kopcami, ale A[i] może być mniejszy od swoich synów, przez co narusza własność kopca. Żeby spełniała się własność kopca, stosujemy procedurę Heapify: Heapify(A, i) 1l := Left(i) 6 if r  heap-size[A] i A[l]> A[i] 2r := Right(i) 7then largest := r 3if l  heap-size[A] i A[l]>A[i] 8if largest  i 4then largest := l 9 then zamień A[i]  A[largest] 5else largest := i 10Heapify(A, largest)

3 Przykład działania procedury Heapify a) b) c) Czas działania Heapify - O(lg n) = O(h) (n - liczba węzłów drzewa, h - wysokość drzewa)

4 Budowanie kopca Z dowolngo drzewa binarnego można zrobić kopiec w sposób wstępujący (bottom-up) Build-Heap(A) 1heap-size[A] := length[A] 2for i:=  length[A]/2  downto 1 3do Heapify(A, i) Czas działania Build-Heap - O(n)

5 Sortowanie przez kopcowanie

6 Sortowanie przez kopcowanie Heapsort(A) 1Build-Heap(A) 2for i := length[A] downto 2 3dozamień A[1]  A[i] 4 heap-size[A] := heap-size[A]-1 5Heapify(A, 1). Czas działania Heapsort: O(n) + (n-1)O(lg n) = O(n lg n).

7 Quicksort - sortowanie szybkie Algorytm sortowania szybkiego jest oparty na technice „dziel i zwyciężaj”. Dziel: Tablica A[p…r] jest dzielona na dwie niepuste podtablice A[p…q] i A[q+1…r] takie, że każdy element A[p…q] jest nie większy niż każdy element A[q+1…r]. Zwyciężaj: Dwie podtablice A[p…q] i A[q+1…r] są sortowane za pomocą rekurencyjnych wywołań algorytmu Quicksort. Quicksort(A, p, r) 1if p < r 2then q := Partition(A, p, r) 3Quicksort(A, p, q) 4Quicksort(A, q+1, r)

8 Dzielenie tablicy Partition(A, p, r) 1x := A[p] 2i := p - 1 3j := r + 1 4while True 5do repeat j := j - 1 6until A[j]  x 7 repeat i := i + 1 8until A[i]  x 9 if i < j 10then zamień A[i]  A[j] 11else return j ij ij ij ij ij

9 Czas działania Quicksort Najgorszy przypadek podziałów:  (n 2 ) Najlepszy przypadek podziałów:  (n lg n) Czas działania w średnim przypadku zbliżony jest do najlepszego:  (nlgn) n n-11 n n n n n (n2)(n2) Najgorszy przypadek lg n n n/2 n/ n n nn n  (n lg n) Najlepszy przypadek

10 Probabilistyczna wersja Randomized-Partition(A, p, r) 1i := Random(p, r) 2zamień A[p]  A[i] 3return Partition(A, p, r) Randomized-Quicksort(A, p, r) 1if p < r 2then q := Randomized-Partition(A, p, r) 3Randomized-Quicksort(A, p, q) 3Randomized-Quicksort(A, q+1, r)

11 Sortowanie przez zliczanie Counting-Sort(A, B, k) 1for i := 1 to k 2do C[i] := 0 3for j := 1 to length[A] 4do C[A[i]] := C[A[i]] + 1 5// C[i] zawiera teraz liczbę elementów równych i 6for i := 2 to k 7do C[i] := C[i] + C[i-1] 8// C[i] zawiera liczbę elementów mniejszych lub równych i 9for j := length[A] downto 1 10do B[C[A[i]]] := A[i] 11 C[A[i]] := C[A[i]] A C C B C

12 Sortowanie pozycyjne Radix-Sort(A, d) 1for i := 1 to d 2do posortuj przez zliczanie tablicę A według cyfry I Sortowanie przez zliczanie i sortowanie pozycyjne działają w czasie liniowym 839  457  839 


Pobierz ppt "Sortowanie: kopce 16 1 14 2 10 3 8 4 7 5 9 6 3 7 2 8 4 9 1 1614108 1 2 3 4 5 6 7 8 9 10 8793241 Parent(i) return i/2 Left(i) return 2i Right(i) return."

Podobne prezentacje


Reklamy Google