Algorytmy i Struktury Danych Sortowanie WYKAD 4 PROWADZCY

Algorytmy i Struktury Danych Sortowanie WYKŁAD 4 PROWADZĄCY: DR PAWEŁ DROZDA

Treść wykładu �Problem sortowania �Sortowanie przez wstawianie (Insertion sort) bąbelkowe (Bubble sort) przez wybór (Selection sort) przez scalanie (Merge sort) szybkie (Quick sort) Przez kopcowanie Przez zliczanie (Counting. Sort) Pozycyjne (Radix sort)

Opis problemu � Ciąg elementów e={e 1, . . . , en} należących do liniowo uporządkowanej przestrzeni < E, ≤ > � Permutacja i 1, . . . , in liczb 1, . . . , n taka, że ei 1 ≤. . . ≤ ein 6, 3, 2, 7, 4, 1, 5 5324613 1233456 6, 3, 7, 2, 4, 1, 5

Sortowanie przez wstawianie Algorytm sortowania Insertion. Sort(A) for j: =2 to length(A) begin key: =A[j] /* Wstaw A[j] w posortowany ciąg A[1. . j-1]. */ i: = j-1 while i>0 i A[i] > key do begin A[i+1] : = A[i] i: = i-1 end A[i+1] : = key end Przykład działania algorytmu 5 2 4 6 1 3 2 5 4 6 1 3 2 4 5 6 1 3 1 2 4 5 6 3 1 2 3 4 5 6

Sortowanie przez wstawianie � Sortowanie w miejscu � Czas działania algorytmu niech n = length(A) pętla for: n-1 razy pętla while: • optymistycznie: 1 przesunięcie • pesymistycznie: n-1 przesunięć • średnio: (n-1)/2 przesunięć � Złożoność: O(n 2) � sortowanie przyrostowe

Sortowania bąbelkowe Algorytm sortowania Bubble. Sort(A) n: =length(A) for i: =1 to n-1 begin for j: =n downto i+1 begin if A[j]<A[j-1] then swap(A[j], A[j-1]) end Przykład działania algorytmu P, E, K, A, W, S A, P, E, K, S, W A, E, P, K, S, W A, E, K, P, S, W

Sortowania bąbelkowe �Sortowanie w miejscu, przyrostowe �Czas działania algorytmu pętla for i: n-1 razy pętla for j: średnio n/2 razy (nawet jeżeli warunek nie jest spełniony) �Złożoność: O(n 2) �Najgorszy przypadek: ciąg posortowany odwrotnie

Sortowania bąbelkowe �Usprawnienia: zmiana kierunku „bąbelków” – Shake sort / Coctail sort Sortowanie grzebieniowe (Comb sort) � rozpiętość = n/1. 3 (wyznaczone empirycznie) � sortuj kolejno wszystkie pary obiektów odległych o rozpiętość � podziel rozpiętość przez 1. 3 i wykonuj ponownie powyższe sortowanie do czasu, gdy rozpiętość osiągnie wartość 1 � Złożoność: prawdopodobnie O(nlogn)

Combsort– Przykład Gap=6 2 Gap=4 1 4 3 8 0 7 2 4 6 Gap=3 0 4 2 4 1 7 3 8 6 Gap=2 0 4 1 4 2 7 3 8 6 Gap=1 0 1 4 2 4 3 7 6 8 Gap=1 0 1 2 4 3 4 6 7 8 dr Paweł Drozda 4 6 8 0 7 1 4 3

Sortowanie przez wybór Algorytm sortowania Selection. Sort(A) n: =length(A) for i: =1 to n-1 begin wybierz najmniejszy element spośród A[i]. . . A[n] i zamień go miejscami z A[i] end 524613 124653 123654 123456

Sortowanie przez wybór �Sortowanie w miejscu, przyrostowe �Czas działania algorytmu pętla for: n-1 razy wyszukanie najmniejszego elementu: od 1 do n razy, średnio n/2 porównań �Złożoność: O(n 2)

Sortowanie przez scalanie �Podziel A w połowie na 2 podciągi �Kontynuuj dzielenie rekurencyjnie �Jeżeli podciągów nie da się już podzielić, scal je sortując Nieposortowany ciąg Podział Scalanie Pojedyncze elementy

Sortowanie przez scalanie Algorytm sortowania Merge. Sort(lo, hi) if lo=hi zakończ m : = (lo+hi)/2 Merge. Sort(lo, m) Merge. Sort(m+1, hi) Merge(lo, m, hi) Przykład dla: 524613 Merge(lo, med, hi) i : = lo, j : = med+1 for k: =1. . . hi-lo+1 begin if A[i]>A[j] begin A’[k] : = A[i], i: =i+1 end else begin A’[k] : = A[j], j: =j+1 end A[lo]. . . A[hi] : = A’[1]. . . A[hi-lo+1]

Sortowanie przez scalanie � Dziel i zwyciężaj � bazuje na obserwacjach: łatwiej posortować krótszy ciąg niż dłuższy łatwiej otrzymać posortowany ciąg ze złączenia 2 posortowanych podciągów, niż z 2 nieposortowanych podciągów (Merge) � z indukcji matematycznej otrzymujemy złożoność O(nlogn) � Wymaga Ω(n) dodatkowej pamięci (Merge)

Sortowanie szybkie �Wybieramy element dzielący p �Dzielimy A na 2 podciągi: < p i ≥ p �Sortujemy niezależnie (rekurencyjnie) te podciągi �Dziel i zwyciężaj

Sortowanie szybkie Algorytm sortowania Quick. Sort(lo, hi) if A[lo]. . . A[hi] zawiera przynajmniej 2 różne wartości begin p: = większa z 2 różnych wartości przestaw elementy w A tak, że dla pewnego k, lo<k≤hi, że elementy A[lo], . . . , A[k] < p i elementy A[k+1], . . . , A[hi] > p Quick. Sort(lo, k) Quick. Sort(k+1, hi) end

Sortowanie szybkie 5 2 4 1 1 2 3 2 3 6 1 3 3 5 6 4 5 6

Sortowanie szybkie �sortuje w miejscu �Złożoność przestawienie elementów – O(n) liczba wywołań rekurencyjnych: � średnio: O(log(n)) � pesymistycznie O(n) średnia złożoność: O(n log(n)) Najszybszy algorytm sortujący, dobra implementacja będzie 2 -3 razy szybsza niż Merge. Sort

Kopiec �Inaczej stóg/sterta �Drzewo binarne, które zawiera elementy e={e 1, . . . , en} należące do liniowo uporządkowanej przestrzeni < E, ≤ > �drzewo zrównoważone �drzewo uporządkowane �węzeł ma własność kopca gdy: WARTOŚĆ(T, RODZIC(T, n)) ≥ WARTOŚĆ(T, n) liście zawsze spełniają własność kopca

Kopiec jako tablica �wierzchołek wstaw do 18 tab[0] �dla i-tego węzła tab[i]: lewe dziecko: tab[2*i+1] prawe dziecko: tab[2*i+2] rodzic: tab[i/2]? 15 12 10 9 3 4 7 6 1 0 1 2 3 4 5 6 7 8 9 18 15 12 10 9 7 6 4 3 1

Z drzewa do kopca � Zamiana wartości: jeżeli węzeł nie spełnia własności kopca, to zamień jego wartość z synem o większej wartośći 10 15 18 18 � Syn może utracić własność kopca 15 10

Konstrukcja kopca �dodawaj nową wartość do sterty i sprawdź czy nie została zaburzona własność kopca dla rodzica nowo dodanego węzła �jeżeli tak, to rekurencyjnie zamieniaj w górę Zamien. WGore(n): r = RODZIC(n) if WARTOŚĆ(n) > WARTOŚĆ (r) begin zamień wartości n i r Zamien. WGore(r) end

Usunięcie korzenia �Wierzchołek kopca zawiera największą wartość �Na miejsce korzenia wstaw ostatni węzeł drzewa �Rekurencyjnie przywróć własność kopca dla korzenia i jego synów Zamien. WDol(n): s = węzeł z większą wartością spośród synów n if WARTOŚĆ(s) > WARTOŚĆ (n) begin zamień wartości n i s Zamien. WDol(s) end

Sortowanie przez kopcowanie �Utwórz kopiec Dla każdego wierzchołka – zaczynając od wierzchołka n/2 do korzenia kopca przywróć własność kopca �Usuwaj po kolei elementy które są korzeniami, aż do momentu dekonstrukcji całego kopca dr Paweł Drozda

Sortowanie przez kopcowanie - przykład 4 5 8 6 7 2 1 4 4 5 8 6 7 2 7 1 6 8 4 5 2 1 dr Paweł Drozda 5 76 4 2 51 7 6 8 6 2 51 1 2 1 4 5 41 2 5 6 2 7 8 2 1

Sortowanie przez zliczanie �Sortowanie bez porównywania elementów �Założenie: sortujemy liczby całkowite �Idea: ile elementów jest mniejsze od liczby x? 1 2 3 4 5 6 7 8 1 2 3 4 5 6 3 6 4 1 3 4 1 4 2 0 2 3 0 1 1 2 3 4 5 6 7 8 1 1 1 3 3 4 4 4 6 2 2 4 7 7 8 2 3 4 5 6

Counting. Sort: for i=1…k do { C[i]=0; } for i=1…n do { C[A[i]]++; } for i=2…k do { C[i] = C[i]+C[i-1]; } for i=n… 1 do { B[C[A[i]]] = A[i]; C[A[i]]--; } O(n) O(k) Ostatecznie: =O(k)+O(n)+O(k)+O(n) =2(O(k)+O(n)) =2 O(k+n)=O(k+n)

Sortowanie pozycyjne Herman Hollerith 1884

Radix sort �Liczby całkowite 0 liczba składa się z d cyfra przybiera wartości od 0 do k-1 329 457 657 1 2 3 839 4 436 5 6 720 7 355 8 9

Radix sort �Sortujemy po kolejnych cyfrach �Sortowanie jest stabilne utrzymuje kolejność występowania dla elementów o tym samym kluczu np. sortowanie rekordu z datą: {d, m, r} �Złożoność obliczeniowa: d*O(n+k)