dziel i rządź” Sortowanie szybkie Jest to algorytm wynalezi

Metody sortowania wykorzystujące procedury rekurencyjne typu
”dziel i rządź”
Sortowanie szybkie
Jest to algorytm wynaleziony w 1960 roku przez Hoare’a. Działa w miejscu.
Niech n > 1.
Dziel: Dzielimy tablicę A[l, . . . , r] na dwie podtablice A[l, . . . , m − 1] i
A[m + 1 . . . , r] takie, że
element A[m] jest już na właściwym miejscu tablicy A[ ];
∀ j < i A[j] ¬ A[m];
∀ j > i A[j] ­ A[m].
Zwyciężaj: Sortujemy otrzymane podciągi wykorzystując rekrencyjnie szybkie sortowanie.
Połącz: Ponieważ szybkie sortowanie jest sortowaniem w miejscu, operacja
połącz jest niepotrzebna.
1
Zadanie 1
a) Przeanalizuj algorytm programu - szybkie sortowanie ze strażnikiem.
Dane wejściowe: lista A[1...n], którą należy przesortować, N = Len([A])
oznacza liczbę elementów listy. Na końcu listy należy dodać strażnika (N + 1 element, który jest większy lub równy od wszystkich elementów
listy – A[N ] = ∞.
QuickSort(A[ ], 0, N − 1);
Dane wyjściowe: przesortowana lista A[n].
Schemat blokowy procedury QuickSort:
procedure QuickSort(A[ ], l : integer, r : integer)
begin
if r = l return ;
m = Partition(A[ ], l, r);
QuickSort(A[ ], l, m − 1);
QuickSort(A[ ], m + 1, r);
end
Schemat blokowy procedury Partition:
function Partition(A[ ], l : integer, r : integer)
begin
i := l, j := r + 1, v := A[l];
do
do
i := i + 1;
while A[i] < v;
do
j := j − 1;
while v < A[j];
if i < j
A[i] ↔ A[j];
end if
while j > i
A[l] := A[j];
A[j] := v;
return j
end
2
b) Niech A oznacza napis SORTOWANIE, Len[A] = 10.
A = [S, O, R, T, O, W, A, N, I, E, Z] – Z - strażnik
QuickSort(0, 9) Partition(0, 9) i = 0, j = 10, v = S
S O R T O W A N I E Z
S O R E O W A N I T Z
S O R E O I A N W T Z
N O R E O I A S W T Z j=7
QuickSort(0, 6) Partition(0, 6) i = 0, j = 7, v = N
N O R E O I A S
N O R E O I A S
N A R E O I O S
N A I E O R O S
E A I N O R O S j=3
QuickSort(0, 2) Partition(0, 2) i = 0, j = 3, v = E
E A I N
E A I N
A E I N j=1
QuickSort(0, 0)
QuickSort(2, 2)
QuickSort(4, 6) Partition(4, 6) i = 4, j = 7, v = O
O R O S
O R O N
O O R N
O O R N j=5
QuickSort(4, 4)
QuickSort(6, 6)
QuickSort(8, 9) Partition(8, 9) i = 8, j = 10, v = W
W T Z
W T Z
T W Z j=9
QuickSort(8, 8)
QuickSort(10, 10)
Jak wygląda drzewo ”dziel i rządź” dla tej tablicy?
c) Jak wykazać poprawność tego algorytmu?
d) Zaimplementuj ten algorytm w języku C dla tablicy znakowej.
3