Przegląd i analiza algorytmów sortowania. Problem sortowania można opisać następująco.

Transkrypt

1 Przegląd i analiza algorytmów sortowania Sortowanie obok przeszukiwania jest jednym z najczęściej spotykanych zadań informatycznych. Problem polega zwykle na uporządkowaniu zestawu rekordów (np. danych personalnych) na podstawie wartości wybranego klucza pola klucza (np. numeru PESEL). W naszym wypadku będziemy zajmować się głównie sortowaniem zbiorów liczb, ale nie narzuca to żadnego ograniczenia stosowanym algorytmom. Problem sortowania można opisać następująco. Mając tablicę S zawierającą n kluczy na pozycjach od 1 do n. Zadaniem naszym jest ułożenie liczb (rekordów) w porządku niemalejącym na pozycjach od 1 do n. Dlaczego sortowanie? Istnieje wiele różnorodnych i ciekawych algorytmów sortowania, co za tym idzie można porównując te algorytmy dowiedzieć się, w jaki sposób należy wybierać najlepszy spośród wielu algorytmów rozwiązujących ten sam problem oraz jak można udoskonalić dany algorytm. Po drugie, problem sortowania jest jednym z niewielu problemów, dla których udało się stworzyć algorytmy o złożoności zbliżonej do dolnego ograniczenia. Dla szerokiej klasy algorytmów sortowania dolne ograniczenie to O(n*lgn) i znamy algorytmy o takiej właśnie złożoności. Można powiedzieć, że dopóki rozważamy tę klasę algorytmów, problem sortowania rozwiązaliśmy w satysfakcjonujący sposób.

2 Do klasy algorytmów sortowania dla których udało nam się stworzyć algorytmy o złożoności bardzo zbliżonej do dolnego ograniczenia, należą wszystkie algorytmy sortujące wyłącznie na podstawie operacji porównania kluczy. Algorytmy sortujące wyłącznie w oparciu o porównanie kluczy mogą porównywać dwa klucze celem określenia, który z nich jest większy, oraz kopiować klucze, ale nie mogą wykonywać na kluczach żadnych innych operacji. Należy zwrócić uwagę że algorytmy sortowania należy analizować nie tylko w oparciu o liczbę wykonanych porównań, ale też liczbę przypisań. Dodatkowo należy także zbadać ilość dodatkowej przestrzeni pamięciowej wymaganej przez algorytmy, poza przestrzenią niezbędną do przechowywania danych wyjściowych. Jeśli dodatkowa przestrzeń w algorytmie jest stała, tzn. nie zwiększa się wraz ze wzrostem n, czyli liczby sortowanych kluczy, algorytm nazywamy sortowaniem bezpośrednim. Zaczynamy od przykładów najprostszych. Sortowanie przez podstawienie. Problem: posortuj n kluczy w porządku niemalejącym Dane: całkowita liczba dodatnia n, tablica kluczy S indeksowana od 1 do n Wynik: tablica S, zawierająca klucze w porządku niemalejącym void exchange_sort(int n, keytype S[]) index i, j; keytype x; for(i=1; i<=n-1; i++) for(j=i+1; j<=n; j++) if(s[j] < S[i]) x=s[j]; S[j]=S[i]; S[i]=x Wyświetlanie tablicy S

3 1) Metoda polega na porównaniu liczby z pozycji i-tej z liczbami z pozycji od (i+1)-tej do n-tej. 2) Kiedy liczba na danej pozycji okazuje się mniejsza od liczby z pozycji i-tej, obie liczby zostają zamienione. 3) W pierwszej iteracji pętli for-i najmniejsza liczba jest umieszczana na pierwszej pozycji, kolejna najmniejsza liczba odnaleziona zostaje umieszczona na pozycji drugiej etc. Analiza algorytmu. Analiza algorytmu bazuje na obserwacji, że mamy do czynienia z podwójną pętlą. Jeśli jako operacje dominująca wybierzemy porównanie: - w pierwszym (i=1) przebiegu pętli for-j warunek sprawdzany jest n-1 razy - w drugim przebiegu (i=2) warunek sprawdzany jest n-2 razy, etc. Zatem dla instrukcji porównania jako instrukcji dominującej złożoność w każdym przypadku: T(n) = n-2 + n-1 = (n-1)*n/2 n 2 /2 T(n) n 2 /2 Jeśli jako operacje dominująca wybierzemy przypisanie: - przy każdym spełnionym warunku wykonywane jest 3 przypisania. Zatem w najgorszym wypadku, gdy zawsze spełniony jest warunek: W(n) 3n 2 /2 Jeśli liczby są zupełnie przypadkowe to w średnim wypadku tylko połowa warunków będzie spełniona i nastąpi połowa przypisań, a zatem

4 A(n) (3n 2 /2)/2 3n 2 /4 Sortowanie przez wstawianie. Problem: posortuj n kluczy w porządku niemalejącym Dane: całkowita liczba dodatnia n, tablica kluczy S indeksowana od 1 do n Wynik: tablica S, zawierająca klucze w porządku niemalejącym void insertion_sort(int n, keytype S[]) index i, j; keytype x; for(i=2; i<=n; i++) x = S[i]; j = i-1; while(j>0 && S[j]>x) S[j+1] = S[j]; j--; S[j+1] = x; Wyświetlanie tablicy S

5 Analiza algorytmu. Złożoność czasowa w najgorszym przypadku. Podstawowa operacja: porównanie wartości klucza S[j] z wartością x. Rozmiar danych: n, czyli liczba kluczy do posortowania. 1) Dla danych wartości i operacja porównania S[j] > x jest wykonywana najczęściej w momencie opuszczania pętli while z powodu przypisania zmiennej j wartości 0. 2) Zatem operacja porównania jest wykonywana co najwyżej i-1 razy dla danego i. 3) Ponieważ i przyjmuje wartości do 2 do n, łączna liczba operacji porównania wynosi co najwyżej: Ʃ n i=2 (i-1) = n*(n-1)/2 Zatem W(n) = n*(n-1)/2 Złożoność czasowa w średnim przypadku. Dla każdej wartości i istnieje i pozycji, na które można wstawić klucz o wartości x. Oznacza to, że wartość x może pozostać na i-tej pozycji lub może zostać przeniesiona na pozycję i-1 lub i-2 lub...1. Wstawienie x na każdą z pozycji jest jednakowo prawdopodobne z prawdopodobieństwem 1/i.

6 Liczba operacji porównania dla wartości x wstawianej na poszczególne pozycje wynosi: Pozycja Liczba porównań i 1 i i-1 1 i-1 jeśli j=0 to drugi warunek w while w ogóle nie jest sprawdzany. Dla danej wartości i średnia liczba wykonywanych operacji porównania, niezbędnych do wstawienia wartości x wynosi: 1*(1/i) + 2*(1/i) + + (i-1)*(1/i) + (i-1)*(1/i) = (1/i)*Σ k=1 k +(i-1)/i = (1/i)*(i-1)*i/2 + (i-1)/i = (i+1)/2 1/i Średnia liczba wykonywanych operacji porównania, niezbędnych do posortowania całej tablicy wynosi: n n n Σ i=2 ( (i+1)/2 1/i ) = Σ i=2 (i+1)/2 Σ i=2 (1/i) (n+4)(n-1)/4 lnn n 2 /4 Zatem: A(n) = (n+4)(n-1)/4 lnn n 2 /4 Podobnie można pokazać,że jeśli wybierzemy operację przypisania jako operację dominującą to liczba takich operacji wyniesie: w najgorszym przypadku W(n)=(n+4)(n-1)/2 n 2 /2 w średnim przypadku A(n) = n(n+7)/4 1 n 2 /4 Jedyną przestrzenią pamięciową, powiększającą się wraz ze wzrostem wartości n, jest rozmiar wejściowej tablicy S. Algorytm i-1

7 sortowania przez wstawianie jest algorytmem bezpośrednim, w którym dodatkowa przestrzeń pamięci wynosi O(1). Wprowadźmy teraz znaczącą modyfikację do algorytmu sortowania przez podstawianie i utwórzmy algorytm przez wybieranie. Sortowanie przez wybieranie. Problem: posortuj n kluczy w porządku niemalejącym Dane: całkowita liczba dodatnia n, tablica kluczy S indeksowana od 1 do n Wynik: tablica S, zawierająca klucze w porządku niemalejącym void selection_sort(int n, keytype S[]) index i, j, smallest; keytype x; for(i=1; i<=n-1; i++) smallest=i; for(j=i+1; j<=n; j++) if(s[j] < S[smallest]) smallest = j; x=s[smallest]; S[smallest]=S[i]; S[i]=x Wyświetlanie tablicy S Analiza algorytmu. Złożość w każdym przypadku. Przyjmując porównanie za operację dominującą możemy powiedzieć, że algorytm ma taką samą złożoność czasową jak algorytm sortowania przez podstawienie, tj. T(n) n 2 /2

8 Przyjmując przypisanie za operację dominującą, występuje duża różnica w porównaniu z algorytmem sortowania przez podstawienie: - zamiast wymieniać rekordy S[i] i S[j] za każdym razem, gdy okazuje się że S[j] jest mniejsze od S[i], algorytm sortowania przez wybieranie jedynie rejestruje indeks najmniejszego znalezionego klucza wśród kluczy na pozycjach od i-tej do n-tej - po znalezieniu takiego rekordu algorytm zamienia go z rekordem na i-tej pozycji. Zatem w każdej kolejnej iteracji pętli for algorytm wstawia kolejny najmniejszy klucz na kolejną pozycje począwszy od pozycji 1 i w każdej iteracji wykonywana jest tylko jedna zamiana kluczy. Cała operacja sortowania wymaga dokładnie n-1 takich zamian. Przyjmując że każda zamiana to 3 operacje przypisania, a zatem: T(n) = 3(n-1) Porównanie najprostszych algorytmów sortowania. Algorytm Porównanie Przypisanie Dodatkowa kluczy rekordów pamięć Sortowanie przez T(n) n 2 /2 W(n) 3n 2 /2 Algorytm podstawienia A(n) 3n 2 /4 bezpośredni Sortowanie przez W(n) n 2 /2 W(n) n 2 /2 Algorytm wstawianie A(n) n 2 /4 A(n) n 2 /4 bezpośredni Sortowanie przez T(n) n 2 /2 T(n) 3n Algorytm wybieranie bezpośredni Algorytm sortowania przez wstawianie vs. przez podstawienia. W zakresie liczby wykonywanych operacji porównywania kluczy algorytm sortowania przez wstawianie nigdy nie jest mniej wydajny od algorytmu przez podstawienie, a w średnim przypadku jest lepszy.

9 W zakresie liczby wykonywanych operacji przypisania rekordów algorytm sortowania przez wstawianie jest lepszy od algorytmu sortowania przez podstawienie zarówno w najgorszym jak i średnim przypadku. Ponieważ obie metody są algorytmami bezpośrednimi można stwierdzić że algorytm sortowania przez wstawianie jest lepszy. Algorytm sortowania przez wybieranie vs. przez podstawienia. W zakresie liczby wykonywanych operacji porównywania kluczy algorytmy sortowania przez podstawienie i algorytm sortowania przez wybieranie są jednakowo wydajne. W zakresie liczby wykonywanych operacji przypisania rekordów algorytm sortowania przez wybieranie jest liniowy w n w przeciwieństwie do dwóch pozostałych które reprezentują zależność n 2. Należy jednak pamiętać, że w niektórych sytuacjach algorytm sortowania przez podstawienie sprawdza się lepiej niż algorytm sortowania przez wybieranie. Jest tak np. gdy rekordy są już posortowane gdyż wówczas algorytm sortowania przez podstawienie nie wykonuje żadnych operacji przypisania. Algorytm sortowania przez wybieranie vs. przez wstawianie: w zakresie liczby wykonywanych operacji porównywania wartości kluczy algorytm sortowania przez wstawianie jest przynajmniej tak dobry jak algorytm sortownia przez wybieranie, a w średnim wypadku jest nawet nieco lepszy w zakresie liczby wykonywanych operacji przypisania rekordów złożoność algorytmu sortowania przez wybieranie jest liniowa w n podczas gdy w przypadku algorytmu sortowania przez wstawianie jest kwadratowa Różnica między złożonością liniową, a kwadratową jest szczególnie istotna w przypadku wielkich wartości n. Jeśli więc wartość n jest duża i duże są rozmiary rekordów (przez co czas wykonania operacji przypisania jest znaczący), algorytm sortowania przez wybieranie powinien okazać się bardziej wydajny.

10 W praktyce żaden z wymienionych algorytmów nie jest przydatny w przypadku ogromnych danych wejściowych, ponieważ złożoność czasowa wszystkich trzech jest kwadratowa zarówno w średnim, jak i najgorszym przypadku. Czy możemy poprawić kwadratową złożoność czasową dla ilości operacji porównania jeśli ograniczymy się do algorytmów należących do tej samej klasy jak trzy wymienione? Klasa o której mowa to algorytmy usuwające co najwyżej jedną inwersję dla jednej operacji porównania przy czym inwersją jest taki układ pary kluczy, że (ki, kj), i < j, ki > kj. Można pokazać (choć dowód wymaga zrozumienia pojęcia permutacja i kilku twierdzeń), że każdy algorytm sortujący n różnych kluczy wyłącznie w oparciu o wyniki porównań ich wartości i usuwających co najwyżej jedną inwersję po każdym porównaniu: w najgorszym przypadku wykonuje co najwyżej n*(n-1)/2 porównań kluczy a w średnim przypadku wykonuje co najmniej n*(n-1)/4 porównań kluczy. INNE ALGORYTMY SORTOWANIA. Sortowanie przez scalanie (przypomnienie). Wersja 1. funkcja sortująca void mergesort2(index low, index high) index mid; if(low<high) mid = (low+high)/2 ; mergesort2(low,mid); mergesort2(mid+1,high); merge2(low,mid,high);

11 funkcja scalająca void merge2(index low, index mid, index high) index i,j,k; keytype U[low..high]; // Tablica lokalna do scalania i=low;j=mid+1;k=low; while(i <= mid && j <= high) if(s[i]<s[j]) U[k] = S[i]; i++; else U[k] = S[j]; j++; k++; if(i>mid) przenies S[j] do S[high] na miejsce U[k] do U[high]; else przenies S[i] do S[mid] na miejsce U[k] do U[high]; przenies U[low] do U[high] na miejsce S[low] do S[high];

12 Analizując powyższy przykład stwierdzamy: gdy scalane są pod-tablice [3 4] i [1 2], po porównaniu usuwana jest więcej niż jedna inwersja. Po porównaniu liczb 3 i 1 liczba 1 jest umieszczana na pierwszej pozycji w tablicy, dzięki temu usuwane są inwersje (3,1) i (4,1). Po porównaniu liczb 3 i 2 liczba 2 jest umieszczana na drugiej pozycji w tablicy, co jest równoznaczne z usunięciem inwersji (3, 2) i (4, 2). Złożoność czasowa algorytmu ze względu na liczbę operacji porównania w najgorszym przypadku wynosi: gdzie n jest potęgą 2. W(n) = n*lgn (n-1) Korzystając z funkcji tworzącej można wykazać, że złożoność czasowa algorytmu ze względu na liczbę operacji porównania w średnim wypadku wynosi: gdzie n jest potęgą 2. lgn A(n) = n*lgn - 2*n*Σ 1/(2 i +2) n*lgn 1.26*n i=1 Złożoność czasowa algorytmu ze względu na liczbę operacji przypisania w każdym przypadku wynosi: T(n) 2*n*lgn Analiza wykorzystania dodatkowej pamięci Algorytm sortowania przez scalanie wymaga dodatkowego zastosowania całej tablicy o rozmiarze n. Kiedy algorytm sortuje pierwszą pod-tablicę, wartości na pozycjach mid, mid+1, low i high muszą być przechowywane na stosie rekordów aktywacji. Ponieważ tablica jest zawsze dzielona na dwie równe części, rozmiar stosu rośnie do osiągnięcia głębokości lgn. Przestrzeń wykorzystywana przez dodatkową tablicę rekordów dominuje, co oznacza, że w każdym przypadku rozmiar dodatkowej pamięci jest nie większa niż Θ(n) (liczba rekordów nie przekracza Θ(n) ).

13 Udoskonalony algorytm sortowania przez scalanie. Sposób 1: wykorzystanie programowania dynamicznego. Rozpoczynamy od początku od zbiorów jednoelementowych, scalamy je w zbiory dwu-elementowe, te grupujemy w czwórki etc. Konstruujemy w ten sposób wersję iteracyjną i unikamy kosztów związanych z operacjami na stosie. Problem: sortowanie n kluczy w porządku niemalejącym Dane: n liczb całkowitych dodatnich, tablica kluczy S, indeksowanych od 1 do n Wynik: tablica S, zawierająca klucze uporządkowane w kolejności niemalejącej void mergesort3(int n, keytype S[]) int m; index low, mid, high, size; // Traktuj rozmiar tablicy jako potęgę liczby 2. m = 2 lgn ; // Zmienna size reprezentuje rozmiar scalanych pod-tablic size = 1; repeat(lgm razy) for (low = 1; low <= m 2*size+1; low = low+2*size) mid = low+size -1; high = minimum(low+2*size 1, n); // Nie scalamy powyżej n merge3(low,mid,high,s); // Zwiekszamy dwukrotnie rozmiar pod-tablic size = 2*size; Gdzie funkcja merge3 może wyglądać podobnie jak merge2. Umiejętne zapisanie scalania pozwala również zmniejszyć liczbę operacji przypisania rekordów, tak że w każdym przypadku złożoność czasowa ze względu na ilość operacji przypisania wynosi: T(n) n*lgn zatem dwukrotnie mniej niż w wersji standardowej.

14 Sposób2: wykorzystanie jednokierunkowej listy dowiązaniowej (wskaźników). Problem: sortowanie n kluczy w porządku niemalejącym Dane: n liczb całkowitych dodatnich, tablica S, zawierająca rekordy danego typu, indeksowane od 1 do n Wynik: tablica S, zawierająca wartości pola key, uporządkowane w kolejności niemalejącej. Rekordy znajdują się na posortowanej jednokierunkowej liście (pole link). struct node keytype key; index link; ; void mergesort4(index low, index high, index& mergedlist) index mid, list1, list2; if(low==high) mergedlist=low; S[mergedlist].link=0; else mid= (low+high)/2 ; mergesort4(low, mid, list1); mergesort4(mid+1, high, list2); merge4(list1, list2, mergedlist); void merge4(index list1, index list2, index& mergedlist) index lastsorted; if(s[list1].key < S[list2].key) //znajdz pocz scalanej listy mergedlist = list1; list1 = S[list1].link; else mergedlist = list2; list2 = S[list2].link; lastsorted = mergedlist;

15 while ( list1!=0 && list2!= 0) if(s[list1].key < S[list2].key) // dolacz mniejszy klucz do // scalanej listy S[lastsorted].link = list1; lastsorted = list1; list1 = S[last1].link; else S[lastsorted].link = list2; lastsorted = list2; list2 = S[last2].link; if(list1 == 0) S[lastsorted].link = list2; else S[lastsorted].link = list1; Wywołanie w programie głównym powinno mieć postać: mergesort4(1, n, listfront); gdzie listfront będzie indeksem pierwszego rekordu posortowanej listy. b

16 Rozwiązanie powyższe jest szczególnie przydatne gdy sortujemy duże rekordy, bo wówczas dodatkowa przestrzeń pamięci wykorzystywana przez algorytm standardowy może być znaczna. Sortowanie rekordów do postaci posortowanej listy jednokierunkowej operuje tylko na dowiązaniach (wskaźnikach), nie ruszając samych rekordów. Można w ten sposób ograniczyć znacznie ilość używanej pamięci, gdyż przestrzeń wymagana do przechowywania dowiązania jest znacznie mniejsza od przestrzeni niezbędnej do przechowywania dużego rekordu. Ograniczamy w ten sposób również czas działania, gdyż operacje na dowiązaniach są znacznie szybsze niż przenoszenie dużych rekordów. Kiedy rekordy są już posortowane można następnie umieścić je w tablicy co wymaga dodatkowo algorytmu klasy Θ(n) biorąc pod uwagę operacje przypisania. Korzyści z wykorzystania listy: eliminacja konieczności przechowywania n dodatkowych rekordów na rzecz przechowywania tylko n dowiązań ograniczenie złożoności czasowej liczby operacji przypisywania rekordów do zera, lub Θ(n) gdy chcemy zwracać posortowane rekordy w postaci tablicy Sortowanie szybkie (przypomnienie). void quicksort(index low, index high) index povotpoint; if(high > low) partition(low, high, pivotpoint); quicksort(low, pivotpoint-1); quicksort(pivotpoint+1, high);

17 Złożoność czasowa w najgorszym przypadku dla operacji porównania: W(n) n*(n-1)/2 Złożoność czasowa w średnim przypadku dla operacji porównania: A(n) 1.38*(n+1)*lgn Cechy charakterystyczne sortowania szybkiego: - kwadratowa złożoność czasowa w najgorszym przypadku - złożoność czasowa w średnim przypadku niewiele gorsza od algorytmu sortowania przez scalanie - przewaga nad algorytmem sortowania przez scalanie polegająca na wyeliminowaniu konieczności wykorzystania dodatkowej tablicy - sortowanie nie jest bezpośrednie, bo podczas sortowania pierwszej pod-tablicy pierwszy i ostatni indeks drugiej pod-tablicy jest przechowywany na stosie rekordów aktywacji - algorytm w przeciwieństwie do sortowania przez scalanie nie daje gwarancji podziału tablicy pośrodku, co skutkuje znaczącym wzrostem złożoności czasowej w najgorszym przypadku. - w najgorszym przypadku na stosie znajduje się n-1 par indeksów, co oznacza że wykorzystanie dodatkowej pamięci wynosi wówczas Θ(n) Średnia liczba operacji zamian rekordów w algorytmie szybkiego sortowania wynosi około 0.69*(n+1)*lgn. Zakładając że operacja zamiany rekordów wymaga trzech przypisań, można stwierdzić że złożoność czasowa w średnim przypadku dla operacji przypisania wynosi: A(n) 2.07*(n+1)*lgn Udoskonalony algorytm sortowania szybkiego. Algorytm sortowania szybkiego można udoskonalić (zmniejszając wykorzystanie dodatkowej pamięci) na kilka sposobów: - w procedurze quicksort określić która pod-tablica jest większa, umieszczać inf o tej pod-tablicy na stosie, a sortować tą drugą. Powoduje to że

18 najgorszy przypadek występuje, gdy tablica jest zawsze dzielona dokładnie na połowy i wówczas głębokość stosu jest nie większa niż Θ(lgn) - zbudować wersję procedury partition, która ogranicza średnią liczbę wykonywanych operacji przypisania rekordów, tak że w średnim przypadku wynosi A(n) 0.69*(n+1)*lgn void partition(index low, index high index& pivotpoint) index i,j; keytype pivotitem; pivotitem=s[low]; i = low; j = high+1; do i++; while(i<high && S[i]<=pivotitem); do j--; while(s[j]>pivotitem); while(i<j) zamień S[i] i S[j]; do i++; while(s[i]<=pivotitem); do j--; while(s[j]>pivotitem); pivotpoint = j; zamień S[low] i S[pivotpoint];//umieszcza pivotitem w pivotpoint - można uniknąć niepotrzebnych operacji odkładania na stosie poprzez zbudowanie iteracyjnej wersji procedury quicksort i manipulując stosem z poziomu tej procedury (tzn. jawnego umieszczania i zdejmowania wartości ze stosu)

19 - wyznaczyć wartość progową dla której algorytm wywołuje procedurę iteracyjną zamiast dalej dzielić przetwarzane dane - wybór jako punktu podziału (pivotitem) mediany z liczb S[low], S[ (low+high)/2 ], S[high] zamiast S[low]. Pozwala to uniknąć najgorszego przypadku, gdy podana tablica jest już posortowana lub bliska posortowania. Daje to też pewność, że dopóki mamy trzy różne wartości, żadna z pod-tablic nie będzie pusta. Stogi i algorytm sortowania stogowego. Przypomnienie: głębokość węzła w drzewie to liczba krawędzi leżących na unikalnej ścieżce prowadzącej od korzenia drzewa do tego węzła, głębokość d drzewa to maksymalna głębokość wszystkich węzłów, a liściem w drzewie nazywamy węzeł nie mający potomków. Węzłem wewnętrznym drzewa jest dowolny węzeł, mający przynajmniej jednego potomka (każdy węzeł nie będący liściem jest węzłem wewnętrznym). Pełnym drzewem binarnym nazywamy drzewo binarne, spełniające warunki: - wszystkie wewnętrzne węzły mają dwóch potomków - głębokość wszystkich liści jest równa d Częściowo pełnym drzewem binarnym nazywamy drzewo binarne, spełniające warunki: - drzewo jest pełnym drzewem binarnym do głębokości d-1 - wszystkie węzły na głębokości d znajdują się po lewej stronie

20 Stogiem nazywamy częściowo pełne drzewo binarne, spełniające warunki: wartości przechowywane w węzłach należą do zbioru uporządkowanego wartość przechowywana w każdym węźle jest większa lub równa wartościom przechowywanym w jego węzłach potomnych (własność stogu) Operacja sprowadzania klucza z korzenia rozpoczyna się od porównania jego wartości z większym z pary kluczy w dwóch węzłach potomnych korzenia. Jeśli klucz w korzeniu jest mniejszy to wartości są zamieniane ze sobą. Proces ten jest powtarzany w coraz niższych poziomach drzewa, aż klucz w sprawdzanym węźle nie będzie mniejszy od większego z kluczy przechowywanych w węzłach potomnych.

21 Proces ten jest realizowany przez procedurę shiftdown: void shiftdown(heap& H) // H początkowo spełnia własność stogu // we wszystkich węzłach z wyj. korzenia node parent, largerchild; // H na końcu jest stogiem parent=korzen stogu H; largerchild=węzeł potomny węzła parent,zawierajacy wiekszy klucz; while (klucz w parent jest mniejszy od klucza w largerchild) zamien klucz w parent z kluczem w largerchild; parent = largerchild; largerchild = wezel potomny parent,zawierajacy wiekszy klucz; Zaś kod wysokiego poziomu usuwający klucz z korzenia i przywracający własność stogu możemy sformułować: keytype root(heap& H) keytype keyout; keyout = klucz w korzeniu root; przenies klucz z najniższego skrajnie prawego węzła do root; usuń najniższy wezeł; shiftdown(h); return keyout; Możemy również zbudować kod umieszczający klucze ze stogu (n kluczy) w posortowanej tablicy S: void removekeys(int n, heap H, keytype S[]) index j for(j=n;j>=1;j--) S[j]=root(H); Jeżeli klucze tworzą już częściowo pełne drzewo binarne to możemy je przekształcić w stóg przez wielokrotne wywołanie procedury shiftdown.

22 Po pierwsze należy przekształcić w stogi wszystkie poddrzewa, których korzenie mają głębokość d-1; po drugie należy przekształcić w stogi wszystkie poddrzewa, których korzenie mają głębokość d-2, etc. Zrealizujemy to za pomocą procedury makeheap: void makeheap(int n, heap& H) // H przekształcamy w stóg index j; heap Hsub; for(j=d-1;j>=0;j--) for(wszystkie poddrzewa Hsub o korzeniach głębokości j) shiftdown(hsub); 8 1

23 Możemy teraz przedstawić pseudo-kod sortowania stogowego (zakładamy że klucze tworzą częściowo pełne drzewo): void heapsort(int n, heap H, keytype S[]) //H jest przekształcane // w stóg makeheap(n,h); removekeys(n,h,s); Algorytm sortowania stogowego jest algorytmem bezpośrednim (tzn. nie wykorzystuje dodatkowej pamięci) jeśli zaimplementujemy stóg za pomocą tablicy i ta sama tablica, która przechowuje dane wejściowe, jest wykorzystywana jako stóg oraz żadnej pozycji w tablicy nie wykorzystujemy do więcej niż jednego celu. Częściowo pełne drzewo binarne możemy przedstawić za pomocą tablicy, umieszczając na pierwszej pozycji korzeń, na drugiej i trzeciej pozycji lewy i prawy węzeł potomny korzenia itd : Indeks lewego potomka węzła jest dwukrotnie większy od indeksu tego węzła, indeks prawego potomka jest dwukrotnie większy od indeksu węzła + 1. Jako punkt startowy możemy umieścić w tablicy klucze w dowolnej kolejności, tak że będą one tworzyły strukturę częściowo pełnego drzewa binarnego. Reprezentacja stogu (struktura danych) i programy składowe sortowania stogowego: struct heap keytype S[1..n]; int heapsize;

24 void shiftdown(heap& H, index j) index parent, largerchild; keytype shiftkey; bool spotfound; shiftkey=h.s[j]; parent=j; spotfound=false; while(2*parent<=h.heapsize &&!spotfound) if(2*parent < H.heapsize && H.S[2*parent]<H.S[2*parent+1]) largerchild = 2*parent+1; else largerchild=2*parent; if(shiftkey < H.S[largerchild]) H.S[parent]=H.S[largerchild]; parent=largerchild else spotfound=true; H.S[parent]=shiftkey; keytype root(heap& H) keytype keyout; keyout=h.s[1]; H.S[1]=H.S[heapsize]; H.heapsize=H.heapsize-1; shiftdown(h,1); return keyout; void removekeys(int n, heap& H, keytype S[]) index j; for(j=n;j>=1;j--) S[j]=root(H); void makeheap(int n, heap& H) index j; H.heapsize=n; for(j= n/2 ;j>=1;j--) shiftdown(h,j);

25 oraz samego sortowania stogowego. Sortowanie stogowe: Problem: sortowanie n kluczy w porządku niemalejącym Dane: n liczb całkowitych dodatnich, tablica zawierająca n kluczy przechowywanych w tablicowej implementacji stogu Wynik: tablica H.S, zawierająca klucze uporządkowane w kolejności niemalejącej void heapsort(int n, heap& S) makeheap(n,h); removekeys(n,h,h.s); Działanie programu: zakładamy, że klucze do posortowania znajdują się już w tablicy H.S, tzn. tworzą strukturę częściowo pełnego drzewa binarnego. po przekształceniu drzewa w stóg klucze są z niego usuwane, począwszy od n-tej pozycji w tablicy w dół aż do pierwszej pozycji Porównanie algorytmów sortowania o złożoności Θ(n*lgn). Algorytm Porównanie Przypisanie Dodatkowa kluczy rekordów pamięć Sortowanie przez W(n) n*lgn T(n) 2 n*lgn Θ(n) rekordów scalanie A(n) n*lgn Sortowanie przez W(n) n*lgn T(n) 0 lub Θ(n) powiązań scalanie z listą A(n) n*lgn Θ(n) jeśli jednokierunkową wymagamy tablicy Sortowanie szybkie W(n) n 2 /2 Θ(lgn) indeksów z ulepszeniami A(n) 1.38n*lgn A(n) 0.69n*lgn Sortowanie stogowe W(n) 2n*lgn W(n) 2n*lgn algorytm A(n) 2n*lgn A(n) n*lgn bezpośredni

26 Dolne ograniczenie dla najgorszego przypadku. Każdy deterministyczny algorytm sortujący n różnych kluczy wyłącznie na podstawie operacji porównania ich wartości musi w najgorszym przypadku wykonać lgn! >= n*lgn -1.45*n. Podobne ograniczenie można znaleźć dla liczby operacji w średnim przypadku. Wydajność algorytmu sortowania przez scalanie w najgorszym przypadku wynosi n*lgn (n-1) i jest bliska wydajności optymalnej!!!. Wydajność algorytmu sortowania przez scalanie w średnim przypadku wynosi n*lgn 1.26*n i jest bliska wydajności optymalnej. Sortowanie przez podział (pozycyjne). Żaden algorytm sortujący wyłącznie na podstawie operacji porównania kluczy nie może być lepszy niż Θ(n*lgn). Jeśli nie mamy żadnej wiedzy o kluczach do sortowania poza tym żę należą do zbioru uporządkowanego to jesteśmy skazani na algorytm porównujący wartości kluczy. Jeśli wiemy coś więcej o elementach do posortowania, możemy rozważyć zastosowanie innych algorytmów sortujących. Założymy że klucze są nieujemnymi liczbami całkowitymi zapisanymi w systemie dziesiętnym i składają się z tej samej liczby cyfr. Możemy wówczas podzielić je między różne stosy na podstawie skrajnie lewej cyfry, a każdy taki stos podzielić dalej na podstawie drugiej od lewej cyfry dziesiętnej itd. Po przeanalizowaniu wszystkich cyfr klucze są posortowane. Trudność w tym algorytmie polega na konieczności sortowania zmiennej liczby stosów.

27 Przykład: Zamiast tego tworzymy 10 stosów (dla każdej cyfry dziesiętnej) i analizujemy cyfry od prawej do lewej strony i zawsze umieszczamy klucz na stosie odpowiadającym aktualnie analizowanej cyfrze. W takim algorytmie klucze nadal będą prawidłowo sortowane, jeśli w każdej iteracji jeśli dwa klucze mają być umieszczone na tym samym stosie, klucz ze skrajnego lewego stosu (w poprzedniej iteracji) jest umieszczany na lewo od drugiego z kluczy. Przykład: liczby do posortowania Liczby rozdzielone zgodnie ze skrajnie prawymi cyframi Liczby rozdzielone zgodnie z drugimi cyframi od prawej Liczby rozdzielone zgodnie z trzecimi cyframi od prawej Sortowanie to przypomina sortowanie kubełkowe dyskutowane na jednym z wcześniejszych wykładów.

28 W algorytmie tym liczba kluczy w poszczególnych stosach jest zmieniana w każdej iteracji, dobrym rozwiązaniem w implementacji jest zastosowanie list jednokierunkowych. Jedna lista powinna reprezentować jeden stos. Zasady działania: po każdej iteracji klucze są usuwane z list (stosów) i łączone w jednej głównej liście. Klucze są w tej liście uporządkowane zgodnie z kolejnością list (stosów), z których zostały usunięte. w kolejnej iteracji lista główna jest od początku przeglądana, a każdy klucz jest umieszczany na końcu listy (stosu), do której ma należeć w bieżącej iteracji. Zmiana założeń (dziesiętne liczby dodatnie) na inny sposób reprezentowania kluczy nie wpływa na złożoność czasową takiego algorytmu. Algorytm wymaga struktury danych: struct nodetype keytype key; nodetype* link; ; typedef nodetype* node_pointer; Algorytm sortowania pozycyjnego Problem: sortowanie n nieujemnych dziesiętnych liczb całkowitych w porządku niemalejącym. Dane: lista jednokierunkowa masterlist, zawierająca n nieujemnych liczb całkowitych oraz liczba całkowita numdigits, reprezentująca maksymalną liczbę dziesiętnych cyfr w każdej z liczb zawartych na liście masterlist.. Wynik: lista jednokierunkowa masterlist, zawierająca liczby całkowite, uporządkowane w kolejności niemalejącej.

29 void div_sort(node_pointer& masterlist, int numdigits) index i; node_pointer list[0..9]; for(i=1;i<=numdigits;i++) distribute(masterlist,i); //rozdzielamy masterlist na stosy coalesce(masterlist); // łączymy stosy w masterlist void distribute(node_pointer& masterlist,index i) //index badanej //cyfry index j; node_pointer p; for(j=0;j<=9;j++) list[j]=null; // czyszczenia bieżących stosów p=masterlist; while(p!=null) j= wartość i-tej cyfry od prawej pola p->key; powiąż (link) p z końcem listy list[j]; p=p->link; void coalesce(node_pointer& masterlist) index j; masterlist = NULL; // Czyszczenie masterlist for(j=0;j<=9;j++) powiąż (link) węzły w list[j] z końcem listy masterlist; Analiza algorytmu Brak w algorytmie operacji porównania więc operacja podstawowa musi być inna niż proste porównanie. W procedurze coalesce listy zawierające stosy powinny przechowywać wskaźniki do swoich początków i końców, bo dzięki temu możemy łatwo

30 dodawać każdą z tych list na koniec poprzedniej bez konieczności jej przeglądania. W każdym cyklu pętli for w coalesce poprzez proste przypisanie adresu do jednej zmiennej wskaźnikowej dodawana jest jedna lista na koniec masterlist. Przypisanie takie potraktujemy jak operację podstawową. W procedurze distribute jako operację podstawową w pętli while wybieramy operację dodawania klucza na koniec listy poprzez przypisanie adresu do zmiennej wskaźnikowej. Jako rozmiar danych wejściowych przyjmujemy: n-liczba liczb całkowitych na liście masterlist oraz numdigits czyli maksymalna liczba cyfr dziesiętnych w każdej z n liczb. W procedurze distribute zawsze przeglądana jest cała masterlist, a zatem w pętli while wykonywane jest n iteracji. Dodanie wszystkich list (stosów) do masterlist wymaga 10-ciu iteracji w pętli for w procedurze coalesce. Każda z procedur wywoływana jest numdigits razy z poziomu div_sort. Zatem złożoność czasowa w każdym przypadku wynosi: T(numdigits, n) = numdigits*(n+10) Θ(numdigits*n) Wnioski: nie jest to algorytm o złożoności Θ(n), bo ta zależy zarówno od numdigits i n. złożoność może być dowolnie duża jeśli przyjmiemy dużą wartość numdigits. Liczba ma 10 cyfr, zatem posortowanie dziesięciu liczb z których największa jest równa będzie wymagało Θ(n 2 ) operacji. W praktyce liczba cyfr jest dużo mniejsza niż liczba liczb do posortowania, np. gdy sortujemy numerów PESEL, n wynosi natomiast numdigits=11 (każdy PESEL zawiera 11 cyfr). Jeśli klucze są unikalne, złożoność algorytmu sortowania pozycyjnego w najlepszym przypadku wynosi Θ(n lgn).

31 Wykorzystanie dodatkowej pamięci w algorytmie. Algorytm nie przydziela pamięci nowym węzłom, ponieważ żaden klucz nigdy nie musi być przechowywany jednocześnie na liście masterlist i na liście reprezentującej stos. Dodatkowe wykorzystanie pamięci wiąże się tylko z reprezentowaniem kluczy na liście jednokierunkowej, tzn. liczba powiązań nie jest większa niż Θ(n).