C++. Algorytmy i struktury danych
103,95 zł
Projektowanie systemów rozproszonych. Wzorce i paradygmaty dla skalowalnych, niezawodnych usług
−30%27,93 zł
Algorytmy i struktury danych z przykładami w Delphi
80,00 zł
Czysta architektura. Struktura i design oprogramowania. Przewodnik dla profesjonalistów
67,00 zł
Sieci komputerowe. Ujęcie całościowe. Wydanie VII
129,00 zł
Data science od podstaw. Analiza danych w Pythonie
57,00 zł

Quicksort

Tutorial
Na ten temat mamy również tutorial „Quicksort”, który ilustruje działanie algorytmu krok po kroku. Zapraszamy do zapoznania się z nim!
Quicksort Przykładowe wykonanie algorytmu quicksort
Quicksort przerzucanie Przykładowe wykonanie operacji przerzucania elementów wokół klucza osiowego
REKLAMA

Quicksort, sortowanie szybkie – algorytm sortowania działający w średnim przypadku w czasie liniowo-logarytmicznym. Algorytm jest oparty na metodzie dziel i zwyciężaj. Nie jest to algorytm stabilny ani wykazujący zachowanie naturalne, jednak ze względu na efektywność jest algorytmem bardzo popularnym.

Przebieg algorytmu

Quicksort jest algorytmem rekurencyjnym, jego działanie można opisać następująco:

  • Wybierz jeden z elementów jako klucz osiowy,
  • Przenieś wszystkie elementy mniejsze od klucza osiowego na jedną stronę tablicy, a pozostałe na drugą,
  • Wywołaj procedurę rekurencyjnie dla części tablicy na lewo od klucza osiowego i na prawo od klucza osiowego.

Wybór klucza osiowego może być dowolny, jednak powinien być jak najszybszy. W praktyce często stosuje się po prostu wybór pierwszego elementu.

Operacja przerzucania elementów powinna musi być zaimplementowana tak, aby wykonywała się w czasie liniowym. Przykładowo, może ona być zdefiniowana w następujący sposób:

  • Przyjmujemy pierwszy element za klucz osiowy.
  • Dla każdego kolejnego elementu:
    • Jeśli jest większy od klucza osiowego, zostawiamy go na miejscu.
    • W przeciwnym razie zamieniamy go miejscami z pierwszym elementem większym od klucza osiowego (wyjątek: jeśli nie znaleźliśmy wcześniej żadnego elementu większego od klucza osiowego, nie robimy nic).
  • Zamieniamy miejscami klucz osiowy z ostatnim elementem mniejszym od niego.

Analiza algorytmu

Jak już wspomniano, operacja przenoszenia elementów odbywa się w czasie liniowym. O złożoności algorytmu decyduje więc to, ile nastąpi rekurencyjnych wywołań funkcji. W przypadku optymistycznym tablica będzie dzielona na pół. Wówczas głębokość drzewa wywołań zależy logarytmicznie od liczby danych wejściowych, czyli optymistyczna złożoność czasowa algorytmu jest rzędu O(n logn). Możemy wykazać, że taki sam rząd złożoności wystąpi w przypadku średnim (dowód jest dostępny w książkach podanych w bibliografii).

Przypadek pesymistyczny występuje wtedy, gdy klucz osiowy za każdym razem znajdzie się na brzegu tabeli. Wówczas przy każdym kolejnym wywołaniu liczba elementów do posortowania jest tylko o 1 mniejsza, zatem funkcja zostanie wywołana n razy. Pesymistyczna złożoność czasowa wynosi zatem O(n2).

Przeanalizujmy złożoność pamięciową algorytmu. Sortowanie szybkie nie potrzebuje co prawda dodatkowej pamięci na przechowywanie sortowanych danych, wymaga jednak pamięci potrzebnej na obsługę rekurencyjnych wywołań funkcji. Rozmiar tej pamięci (podobnie jak czas wykonania) będzie zależał od głębokości drzewa wywołań. Złożoność pamięciowa wynosi więc O(logn) w przypadku średnim i O(n) w przypadku pesymistycznym. Nie jest to zatem algorytm sortujący w miejscu.

Zastanówmy się, kiedy może wystąpić przypadek pesymistyczny. Jeśli jako klucz osiowy obieramy pierwszy (lub ostatni) elementu z tablicy, to najgorszy przypadek wystąpi wtedy, gdy tablica jest już posortowana. Widzimy więc, że algorytm nie zachowuje się w sposób bardzo nienaturalny.

Możliwe usprawnienia

Niedoskonałości algorytmu można nieco poprawić stosując następujące techniki:

  • Jako klucz osiowy zamiast pierwszego elementu można obierać element losowy. Nie zmieni to złożoności algorytmu, jednak sprawi, że przypadek pesymistyczny nie będzie występował w przypadku tablicy posortowanej.
  • Przy wyborze klucza osiowego można zastosować nieco bardziej złożone techniki. Jednym z rozwiązań jest wybór mediany z kilku wybranych elementów (np. pierwszego, ostatniego i środkowego). Należy jednak uważać, żeby nie spowolniło to zbytnio całej procedury – siła omawianego algorytmu tkwi w tym, aby wybór klucza osiowego i przestawianie elementów było jak najszybsze.
  • W celu zmniejszenia liczby rekurencyjnych wywołań funkcji, dla małych tablic można zastosować jakiś prosty, nierekurencyjny algorytm sortowania, np. sortowanie przez wstawianie (wówczas mamy do czynienia z algorytmem hybrydowym).
  • Jeśli wartość klucza osiowego powtarza się w tablicy, można od razu ustawić te elementy obok klucza osiowego i nie włączać tego fragmentu tablicy do wywołań rekurencyjnych. Taka modyfikacja jest określana jako Quick Sort 3 Way Partition.

Kod źródłowy

Przykładowa implementacja algorytmu w języku C wygląda następująco:

void quicksort(int* tab, int poczatek, int n)
{
    if (n > 1) 
    {
        int liczba_mniejszych = 0;
        int liczba_wiekszych = 0;
        
        int koniec = poczatek + n;
        int t; // Zmienna tymczasowa
    
        // Przeniesienie elementow wokol klucza osiowego
        for (int i = (poczatek + 1); i < koniec; ++i)
        {
            
            if (tab[i] < tab[poczatek])
            {   
                if (liczba_wiekszych > 0)
                {
                    // Przeniesienie elementu mniejszego od klucza osiowego
                    // przed elementy wieksze od klucza osiowego
                    t = tab[poczatek+liczba_mniejszych+1];
                    tab[poczatek+liczba_mniejszych+1] = tab[i];
                    tab[i] = t;
                }                    
                ++liczba_mniejszych; 
            }
            else
            {
                ++liczba_wiekszych;
            }
            
        }
        
        // Wstawienie klucza osiowego na wlasciwe miejsce
        t = tab[poczatek+liczba_mniejszych];
        tab[poczatek+liczba_mniejszych] = tab[poczatek];
        tab[poczatek] = t;
        
        // Wywołanie rekurencyjne
        quicksort(tab, poczatek, liczba_mniejszych);
        quicksort(tab, koniec-liczba_wiekszych, liczba_wiekszych);
        
    }
}

// Przykladowe uzycie funkcji
int main()
{
    int tab[] = {3, 7, 5, 1, 5, 8, 4, 2};
    quicksort(tab, 0, 8);
    
    return 0; 
}

Bibliografia

  1. T.H. Cormen, Ch.E. Leiserson, R.L. Rivest, C. Stein, Wprowadzenie do algorytmów, Wydawnictwo Naukowe PWN, Warszawa, 2012.
  2. Z.J. Czech, S. Deorowicz, P. Fabian, Algorytmy i struktury danych. Wybrane zagadnienia, Wydawnictwo Politechniki Śląskiej, Gliwice, 2010.
  3. Quick Sort (3 Way Partition) - Sorting Algorithm Animations | Toptal [dostęp: 5 stycznia 2018]
Ocena: 0 Tak Nie
Liczba głosów: 0.

Dodano: 5 stycznia 2018 18:56, ostatnia edycja: 11 stycznia 2018 19:53.

REKLAMA

Zobacz też

Algorytm Johnsona – algorytm służący do wyznaczania najkrótszych ścieżek pomiędzy każdą parą wierzchołków w grafie. Algorytm wykorzystuje algorytm Dijkstry i algorytm Bellmana-Forda. Dopuszcza krawędzie o ujemnych wagach, o ile nie tworzą ujemnych cykli.

Złożoność czasowa algorytmu (jeśli algorytm Dijkstry zostanie zaimplementowany z wykorzystaniem kopca Fibonacciego) to O(n2log n + en), gdzie n jest liczbą wierzchołków, a e jest liczbą krawędzi. Dla grafów rzadkich (ze stosunkowo małą liczbą krawędzi) jest to złożoność lepsza, niż złożoność algorytmu Floyda-Warshalla.

→ Czytaj całość

Przeszukiwanie w głąb (ang. depth-first search, w skrócie DFS) – jeden z dwóch podstawowych algorytmów przeszukiwania grafu. Polega na przechodzeniu zawsze do kolejnego nieodwiedzonego wierzchołka. Jeśli dany wierzchołek nie ma nieodwiedzonych sąsiadów, wracamy do poprzedniego wierzchołka i sprawdzamy jego sąsiadów. Mówiąc obrazowo, w algorytmie tym wchodzimy tak głęboko, jak to możliwe (przechodzimy dalej, dopóki się da).

Algorytm można zapisać w sposób rekurencyjny. Wywoływana rekurencyjnie procedura działa następująco: oznacz wierzchołek jako odwiedzony, a następnie wywołaj tę procedurę dla każdego sąsiada danego wierzchołka, jeśli nie został on wcześniej odwiedzony. Na początku wywołujemy procedurę dla wierzchołka początkowego.

→ Czytaj całość

Stos (ang. Stack) – struktura danych, w której bezpośredni dostęp jest tylko do ostatnio dodanego elementu. Stos bywa określany także jako kolejka LIFO (z ang. Last In, First Out, czyli: ostatni na wejściu, pierwszy na wyjściu). Stos można sobie wyobrazić jako kilka rzeczy ułożonych „jedna na drugiej” – łatwo można wziąć tylko rzecz leżącą na samym wierzchu, gdyż pozostałe są przykryte.

→ Czytaj całość
Polityka prywatnościKontakt