Třídění Seminář IVT

Definice uspořádání skupiny dat (záznamů) dle daného klíče vzestupně (od nejmenší do největší hodnoty klíče) sestupně (od největší do nejmenší hodnoty klíče) příklady data žáků, pracovníků, … jistých osob dle příjmení a jména (podle abecedy) – kombinovaný klíč data narození místa bydliště knihy v knihovně dle autora žánru

Druhy třídění vnitřní všechna tříděná data se vejdou do paměti rychlost třídění závisí jen na počtu porovnání a výměn dat vnější data se do paměti nevejdou třídí se po částech, setříděné části odkládají zpět do vnější paměti, pak se vše postupně slučuje rychlost třídění závisí na počtu porovnání, výměn dat a přístupové rychlosti vnějších pamětí (disku)

Metody stabilní - zachovává vzájemné pořadí údajů se shodnými primárními klíči – tj. třídíme-li osoby dle příjmení a bude se vyskytovat více osob stejného příjmení, zachová se ve výsledku jejich pořadí dle původních dat přirozená, pokud doba potřebná ke třídění již setříděné posloupnosti je menší než doba, potřebná pro setřídění náhodně uspořádané posloupnosti.

Požadavky na algoritmus jednoduchost přirozenost stabilita časová složitost co možná nejmenší paměťová náročnost

Algoritmy s časovou složitostí O(N 2 ) kvadratická složitost Select Sort Bubble Sort Shaker Sort Insert Sort třídíme v původní poli, nepotřebujeme další pomocné pole

Select Sort Třídění výběrem – opakovaný výběr největšího (nejmenšího) prvku z dosud nesetříděné posloupnosti a jeho přehození s posledním (prvním) prvkem 1.průchod polem – v n-prvkovém poli najdeme maximum a prohodíme tento prvek s posledním n-tým prvkem 2.průchod polem – v poli s (n-1) prvky opět najdeme maximum a prohodíme tento prvek s posledním tj. (n-1). prvkem 3.průchod polem – v poli s (n-2) prvky opět najdeme maximum a prohodíme tento prvek s posledním tj. (n-2). prvkem … pokračujeme, dokud nezbude jen jediný prvek – ten už je na svém místě

Select Sort i = n, n-1 … 2 j = 2, 3, … i max = 1 A[j] > A[max] max = j tmp = A[i] A[i] = A[max] A[max] = tmp + - Start Stop

SelectSort procedure SelectSort ( var A: TPole ; N : word); var I, J, max : word; tmp : TPrvek; {typ prvku pole} begin for I := N downto 2 do begin max := 1 ; for J := 2 to I do begin if A[J] > A[max] then max := J end; tmp := A[I]; A[I] := A[max]; A[max] := tmp end end;

Bubble Sort třídění probubláváním – porovnávají se vždy prvky ležící vedle sebe – je-li levý prvek větší než pravý, prohodí se 1.průchod polem – n-prvkové pole – porovná se první prvek s druhým, je-li první větší než druhý, prohodí se. Porovná se druhý se třetím (event. se prohodí), třetí se čtvrtým …Touto cestou se na pozici posledního tj n. prvku dostane největší prvek 2.průchod polem – (n-1) prvkové pole – opět se porovnává první s druhým, druhý s třetím atd. na pozici (n-1). prvku se dostane – probublá – 2. největší prvek … pokračujeme, dokud nezbude jen jediný prvek – ten už je na svém místě Zkrácení algoritmu – kontrolujeme, zda došlo k výměně – pokud nikoliv, je celé pole setříděno!!!

Bubble Sort – delší verze i = 1, 2 … n - 1 j = 1, 2, … n - i A[j] > A[j + 1] tmp = A[j] A[j] = A[j+1] A[j+1] = tmp Start Stop + -

Bubble Sort procedure BubbleSort ( var A: TPole ; N : word); var I, J : word; tmp : TPrvek; begin for I := 1 to N - 1 do for J := 1 to N - i do if A[J] > A[J+1] then begin tmp := A[J]; A[J] := A[J+1]; A[J+1] := tmp end;

Bubble Sort – zkrácená verze i = 1, 2 … n -1 j = 1, 2, … n - i A[j] > A[j + 1] tmp = A[j] A[j] = A[j+1] A[j+1] = tmp + - vymena = true vymena = false vymena + - Stop Start

Bubble Sort – zkrácená verze procedure BubbleSort ( var A: TPole ; N : word); var I, J : word; tmp : TPrvek; vymena : boolean; begin for I := 1 to N - 1 do begin vymena := false; for J := 1 to N - i do begin if A[J] > A[J+1] then begin vymena := true; tmp := A[J]; A[J] := A[J+1]; A[J+1] := tmp end; if not vymena then break; end;

Shaker Sort třídění setřásáním – podobné jako BUBBLE SORT, ale střídavě se prochází oboustranně 1.průchod polem – zprava – porovná se poslední s předposledním, předposlední s předpředposledním … 2.průchod polem – zleva – porovnává se první s druhým, druhý s třetím atd. nyní máme na prvním a posledním místě správné prvky – nejmenší a největší pokračujeme v poli s n-2 prvky Zkrácení algoritmu – pamatujeme si, u jakého prvku došlo k výměně

Shaker Sort – setřásání j = R, R-1, … L A[j] < A[j - 1] tmp = A[j] A[j] = A[j -1] A[j -1] = tmp Start + - L=2 R = n + Stop L = L+1 j = L, L+1, … R A[j] < A[j - 1] tmp = A[j] A[j] = A[j -1] A[j -1] = tmp - R = R - 1 L > R

Shaker Sort var I, J, L, R : word; tmp : TPrvek; begin L := 2; R := N; repeat for J := R downto L do begin if A[J-1] > A[J] then begin tmp := A[J-1]; A [J-1] := A[J]; A[J] := tmp; end; L := L+1; for J := L to R do if A[J-1] >A[J] then begin tmp :=A[J-1]; A[J-1] := A[J]; A[J] := tmp; end; R := R - 1; until L > R end;

Shaker Sort – setřásání zkráceně j = R, R-1, … L A[j] < A[j - 1] tmp = A[j] A[j] = A[j -1] A[j - 1] = tmp K = j Start + - L=2 R = n K = n + Stop L = K+1 j = L, L+1, … R A[j] < A[j - 1] tmp = A[j] A[j] = A[j - 1] A[j -1] = tmp K = j - R = K - 1 L > R

Shaker Sort - zkráceně var I, J, L, R, K : word; tmp : TPrvek; begin L := 2; R := N; repeat for J := R downto L do begin if A[J-1] > A[J] then begin tmp := A[J-1]; A [J-1] := A[J]; A[J] := tmp; K := J ; end; L := K+1; for J := L to R do if A[J-1] >A[J] then begin tmp :=A[J-1]; A[J-1] := A[J]; A[J] := tmp; K := J ; end; R := K - 1; until L > R end;

Insert Sort třídění zatřiďováním – jednotlivé prvky se postupně zatřiďují do již setříděné části pole zatřiďování z pravého konce setříděného pole (se zarážkou – nárazníkem) binární zatřiďování

Insert Sort i = 2, 3 … n X < A[j] A[j+1] = A[J] j = j – X = A[i] A[0] = X j = i - 1 Stop Start A[j+1] = X

Insert Sort procedure InsertSort ( var A: TPole ; N : word); var I,J : word; X : TPrvek; begin for I := 2 to N do begin X := A[I]; A[0] := X; J := I-1; while X < A[J] do begin A[J+1] := A[J]; J := J - 1 end; A[J+1] := X end end;

Binary Insert Sort i = 2, 3 … n X < A[M] R = M – 1 Start Stop + - X = A[i] L = 1 R = i – 1 L = M + 1 M = int(L + R)/2 L >R + - j = i, i - 1 … L+1 A[L] =X A[j] = A[j-1]

Binary Insert Sort - složitost n.log(n) procedure BinaryInsertSort(var A : TPole ; N : word) ; var i, j, L, R, M : word; X : TPrvek; begin for i := 2 to N do begin X := A[i] ; L := 1 ; R := i - 1; while L <= R do begin M := (L + R) div 2 ; if X < A[M] then R := M - 1 else L := M + 1; end; for j := i downto L + 1 do A[j] := A[j - 1]; A[L] := X; end end;