METODE DE SORTARE A

VECTORILOR





ELEVI: Chiriac Andrei
Stoicescu Alexandru
Dima Stefan

CLASA: a X-a C
COLEGIUL NATIONAL N. GRIGORESCU CAMPINA



2



INTRODUCERE

n viaa de zi cu zi ntlnim operaii de sortare (mai mult sau mai puin evidente), acest fapt
fiind o consecin a necesitii crerii unor prioriti pentru obiecte, fenomene sau chiar noiuni
abstracte (numere, etc.). Odat cu apariia sistemelor informatice (bazate pe mrimi numerice),
sortrile din lumea real au devenit sortri de diferite chei (care pot fi numerice, de caractere, etc.).
De aceea au aprut i algoritmii de sortare, care sunt implementri, riguroase, ale algorimilor pe care
omul i aplic n viaa de zi cu zi.

Se consider un set finit de obiecte, fiecare avnd asociat o caracteristic, numit cheie,
care ia valori ntr-o mulime pe care este definit o relaie de ordine.

Sortarea este procesul prin care elementele setului sunt rearanjate astfel nct cheile lor s
se afle ntr-o anumit ordine.

Exist numeroase metode de sortare a cror eficien se msoar dup timpul de execuie i
memoria folosit. n general, acestea sunt criteriile dup care este aleas o metod de sortare sau
alta pentru rezolvarea problemei date.

Metodele de sortare se clasific n
metode directe (simple);
metode avansate.

Metodele directe se bazeaz pe algoritmi de dificultate redus, uor de gsit i de neles.
Complexitatea acestor algoritmi este, de cele mai multe ori, O(n
2
), algoritmii de acest fel fiind numii
algoritmi ptratici.

A. Metodele directe de sortare
A1. Sortarea prin selecie

Selecia direct este una dintre cele mai simple metode de sortare, metod care lucreaz
foarte bine pentru numr mic de elemente, fiecare element fiind mutat cel mult o dat.
Algoritmul presupune ca la fiecare pas i s se gseasc elementul minim dintre T[i+1],
T[i+2],, T[n] i s se interschimbe cu T[i].

9 5 8 3 12 4 7
i=1 3 5 8 9 12 4 7
i=2 3 4 8 9 12 5 7
i=3 3 4 5 9 12 8 7
i=4 3 4 5 7 12 8 9
i=5 3 4 5 7 8 12 9
i=6 3 4 5 7 8 9 12

3

Exemplu de sortare prin selecie



Algoritmul metodei de sortare prin selecie este urmtorul:

pentru i 1, n-1 execut
k i
min T[i]
pentru j i +1, n execut
dac T[j] < min atunci
min T[j]
k j
sfrit dac
sfrit pentru
T[k] T[i]
T[i] min
sfrit pentru



Observaie
Algoritmul are ordinul de complexitate O(n
2
).

Tabelul de mai jos conine implementarea n Pascal a algoritmului de sortare prin selecie:

Limbajul Pascal
var T: array[1..20] of integer;
n,i,j,k,min:integer;
begin
write('nr elemente='); readln(n);
for i:=1 to n do
begin
write('T[',i,']='); readln(T[i]);
end;
for i:= 1 to n-1 do
begin
k:=i;
min:=T[i];
for j:= i+1 to n do
if T[j] < min then begin
min:=T[j];
k:=j;
end;
T[k]:=T[i];
T[i]:=min;
end;
for i:=1 to n do
write(T[i],' ');
end.
4



A2. Sortarea prin inserie

Inseria direct aparine familiei de tehnici de sortare care se bazeaz pe metoda juctorului
de bridge. nainte de a examina nregistrarea T[i], vom considera c nregistrrile precedente T[1],
, T[i-1] au fost deja sortate, apoi vom insera T[i] n locul ce i revine ntre nregistrrile sortate
anterior.

Se consider 1 i n i nregistrrile T[1], T[2], , T[i-1] aranjate astfel nct T[1] T[2]
T[i-1]. Vom compara pe rnd noua cheie T[i] cu T[i-1], T[i-2], , pn ce vom descoperi c T[i]
trebuie inserat ntre nregistrrile T[k] i T[k+1]; apoi deplasm nregistrrile T[k+1], ..., T[i+1] cu un
spaiu i introducem noua nregistrare n poziia k+1. Deoarece T[i] intr la locul su aceast
metod a fost denumit metoda de cernere sau scufundare.

Algoritmul metodei de sortare prin inserie este:
pentru i 2, n execut
k 1
ct timp T[k] < T[i] execut
k k +1
sfrit ct timp
dac i k atunci
temp T[i]
pentru j i, k+1, -1 execut
T[ j] T[ j-1 ]
sfrit pentru
T[k] temp
sfrit dac

sfrit pentru


T 9 5 8 3 12 4 7
i=2 5 9 8 3 12 4 7
i=3 5 8 9 3 12 4 7
i=4 3 5 8 9 12 4 7
i=5 3 5 8 9 12 4 7
i=6 3 4 5 8 9 12 7
i=7 3 4 5 7 8 9 12

Exemplu de sortare prin inserie

Observatii
1: Este convenabil s se combine operaiile de comparare i deplasare, ns pentru cazul
defavorabil algoritmul are ordinul de complexitate O(n
2
).
2: Deoarece elementele ntre care se face inseria sunt deja ordonate, pentru o mbuntire a
metodei, se poate folosi algoritmul de cutare binar. Astfel aflarea poziiei pe care se face inseria
va fi mult mai rapid. Aceast metod poart numele de sortare prin inserie binar i a fost
menionat de John Mauchly n 1946, n prima discuie public referitoare la sortarea cu calculatorul.
5


Tabelul de mai jos conine implementarea n Pascal a algoritmului de sortare prin inserie:

Limbajul Pascal
var T: array[1..20] of integer;
i, j, k, temp, n : integer;
begin
write ('nr elemente='); readln (n);
for i:=1 to n do begin
write ('T[',i,']='); readln (T[i]);
end;
for i:=2 to n do
begin
k:=1;
while T[k] < T[i] do k:=k+1;
if i < > k then begin
temp:=T[i];
for j:=i downto k+1 do
T[j]:=T[j-1];
T[k]:=temp;
end;
end;
for i:=1 to n do write(T[i],' ');
end.

Dei sortarea prin selecie pare a fi o metod brutal, ea are un avantaj deloc de neglijat, i
anume, faptul c numrul de interschimbri de elemente din vector este O(n) chiar dac timpul de
execuie este O(n
2
). Aceast caracteristic devine important atunci cnd elementele din vector
conin informaie satelit mare. n acest caz, la fiecare interschimbare trebuie mutat o cantitate
mare de date iar sortarea prin selecie minimizeaz tocmai acest numr de interschimbri. Metoda
de sortare prin inserie este remarcabil atunci cnd vectorul este aproape sortat, fapt pentru care
este aplicat n cadrul unor algoritmi mult mai performani, n anumite etape intermediare. Algoritmul
efectueaza pentru cazul mediu de doua ori mai putine comparatii decat pentru cazul cel mai
nefavorabil. Totui, algoritmii de sortare prin selecie i prin inserie necesit timp ptratic O(n
2
), att
n cazul mediu, ct i n cazul cel mai nefavorabil. Cu toate acestea algoritmi sunt exceleni pentru
cazuri mici.
A3. Sortarea prin metoda bulelor (Bubble Sort)

Aceast metod se rezum la a compara fiecare element cu celelalte, fcndu-se
interschimbarea dac elementul mai mare are indexul mai mic. Se repet parcurgerea vectorului, cu
interschimbul elementelor care nu respect relaia de ordine, pn se ajunge la o parcurgere fr
interschimb. Pentru a reine dac au loc interschimbri ntre elemente, se folosete o variabil inv cu
dou valori posibile: 0(fals), dac nu a avut loc nici un interschimb i 1(adevrat) dac s-a realizat
cel puin un interschimb.
La prima trecere prin vector se vor analiza perechile de elemente consecutive (T[i], T[i+1]), cu
i = 1, 2, , n-1 i pentru fiecare pereche, dac este cazul, se va face interschimbul. Observm c
dup prima parcurgere, dei vectorul nu este neaprat sortat, pe ultima poziie a ajuns elementul cel
mai mare din vector. La fel se va ntmpla i n continuare, elementele mari migrnd spre captul
6

din dreapta al vectorului. Acest mod de lucru a dat denumirea metodei, prin asemnare cu bulele de
aer dintr-un vas cu ap care se ridic la suprafa.


V
e
c
t
o
r
u
l

i
n
i

i
a
l

D
u
p

p
r
i
m
a

t
r
e
c
e
r
e

D
u
p

a

d
o
u
a

t
r
e
c
e
r
e

D
u
p

a

t
r
e
i
a

t
r
e
c
e
r
e

D
u
p

a

p
a
t
r
a

t
r
e
c
e
r
e

D
u
p

a

c
i
n
c
e
a

t
r
e
c
e
r
e

(
V
e
c
t
o
r

s
o
r
t
a
t
)


7 7 12 12 12 12 12
6 4 7 9 9 9 9
5 12 4 7 8 8 8
4 3 9 4 7 7 7
3 8 3 8 4 5 5
2 5 8 3 5 4 4
1 9 5 5 3 3 3

Exemplu de sortare prin metoda bulelor

Algoritmul de sortare prin metoda bulelor este urmtorul:



repet
inv fals
pentru i 1, n -1 execut
dac T[i] > T[i+1] atunci
aux T[i]
T[i] T[i+1]
T[i+1] aux
inv adevarat
sfrit dac
sfrit pentru
pn cnd inv=fals


Tabelul de mai jos conine implementarea n Pascal a algoritmului de sortare prin metoda
bulelor:
Limbajul Pascal
var T: array[1..20] of integer;
n, i, aux: integer;
inv: boolean;
begin
write('nr elemente='); readln(n);
for i:=1 to n do
begin
write('T[',i,']='); readln(T[i]);
end;
for i:= 1 to n-1 do
if T[i] > T[i+1] then begin
aux:=T[i];
T[i]:=T[i+1];
T[i+1]:=aux;
inv:=true;
end;
until not inv;
for i:=1 to n do
7

repeat
inv:=false;

write (T[i],' ');
readln
end.
Observaie
O mbuntire a acestei metode se poate realiza dac observm c dup prima trecere prin
vector elementul cel mai mare ajunge pe locul su final, la a doua trecere un alt element (cel mai
mare din cele rmase pe poziiile 1 ... n-1) ajunge i el pe poziia final, pe poziia n-1, i aa mai
departe.
n concluzie, putem folosi o variabil k care s numere trecerile prin vector i de fiecare dat
s se verifice elementele T[1],, T[n-k], unde k va lua valori de la 1 la numrul de treceri prin vector
necesare ordonrii.

Algoritmul de sortare prin metoda bulelor se modific astfel:
k 0
repet
k k + 1
inv fals
pentru i 1, n - k execut
dac T[i] > T[i+1] atunci
aux T[i]
T[i] T[i+1]
T[i+1] aux
inv adevarat
sfrit dac
sfrit pentru
pn cnd inv=fals
A4. Sortarea prin numrare
Aceast sortare se bazeaz pe idea c elementul de pe poziia j din secvena final sortat este
mai mare dect (j-1) dintre celelalte elemete. Adic, dac tim c o anumit cheie este mai mare
decat alte 20 de chei, nregistrarea respectiv trebuie aezat n poziia 21.
Deci, se compar fiecare pereche de chei, numrnd cte vor fi mai mici dect fiecare cheie
particular.
Calea de a face comparaiile este urmtoarea: compar ((T[i] cu T[j]) pentru 1 j n) pentru 1
i n.Algoritmul metodei de sortare prin numrare este urmtorul:
pentru i 1, n execut
NR[i] 1
sfrit pentru
pentru i 1, n execut
pentru j 1, n execut
dac T[i] > T[j] atunci
NR[i] NR[i] + 1
sfrit dac

sfrit pentru
sfrit pentru
8

pentru i 1, n execut
VS[ NR[i] ] T[i]
sfrit pentru
Observaii
1: Algoritmul nu face nici o modificare pe vectorul iniial, dar folosete un vector (NR) care ine
indexul pe care l-ar avea fiecare nregistrare dac nregistrrile ar fi sortate fizic. Vectorul sortat
este VS.
2: Algoritmul funcioneaz numai pentru valori distincte.
3: Algoritmul are ordinul de complexitate O(n
2
) i este foarte ineficient pentru numr mare de
valori (dublarea numrului de valori crete de 4 ori timpul de rulare).

Deoarece o parte din comparaiile realizate n algoritmul de mai sus nu sunt necesare (nu
este nevoie s se compare cheile cu ele nsele i nici s comparm T[i] cu T[j] i apoi T[j] cu T[i]), s-a
recurs la o mbuntire a algoritmului n care se compar ((T[i] cu T[j]) pentru 1 j i-1) pentru 2
i n. Secvena modificat este:

pentru i 2, n execut
pentru j 1, i - 1 execut
dac T[i] > T[j] atunci
NR[i] NR[i] + 1
altfel
NR[j] NR[j] +1
sfrit dac

sfrit pentru
sfrit pentru

T 9 5 8 3 12 4 7
NR 1 1 1 1 1 1 1
i=2 2 1 1 1 1 1 1
i=3 3 1 2 1 1 1 1
i=4 4 2 3 1 1 1 1
i=5 4 2 3 1 5 1 1
i=6 5 3 4 1 6 2 1
i=7 6 3 5 1 7 2 4
VS 3 4 5 7 8 9 12

Exemplu de sortare prin numrare

Tabelul de mai jos conine implementarea n Pascal a algoritmului de sortare prin numrare:
Limbajul Pascal
var T, NR, VS: array[1..20] of integer;
n,i,j: integer;
begin
write ('nr elemente=');
readln (n);
for i:=1 to n do
begin
write ('T[',i,']=');
readln (T[i]);
end;
for i:= 1 to n do
NR[i]:=1;
for i:= 2 to n do
for j:= 1 to i-1 do
if T[i] > T[j] then
NR[i]:=NR[i]+1
else
NR[j]:=NR[j]+1;
for i:=1 to n do
VS[NR[i]]:=T[i];
9

for i:=1 to n do
write (VS[i],' ');
end.
B. Algoritmi avansai de sortare


Metodele avansate se bazeaz pe algoritmi puin mai complicai dar cu ordin de complexitate
mult mai bun.

B1. Sortarea prin interclasare

Aceast metod de sortare se bazeaz pe tehnica Divide et Impera. Principiul metodei este
urmtorul:
Divide partiionarea problemei n mai multe subprobleme. n cazul algoritmului
nostru, partiionarea unui vector iniial T[p], , T[q] n doi subvectori T[p], , T[m] i T[m+1],
, T[q], unde m se obine prin formula [(p+q)/2]
Impera rezolvarea problemelor obinute la pasul anterior. Se va apela recursiv
algoritmul pentru cele dou partiii create. Dac subproblema obinut este cu rezolvare
direct, atunci se va rezolva (dac partiia are 1 element atunci problema este rezolvat, iar
dac sunt 2 elemente nesortate, atunci se va face interschimbarea acestora).
Combine combinarea soluiilor obinute pentru subprobleme ntr-o soluie pentru
problema iniial. Aceast etap se realizeaz prin procedeul numit interclasare: avnd doi
vectori sortai, se interclaseaz elementele i se obine un vector ordonat care conine
elementele celor doi vectori iniiali).

Algoritmul metodei de sortare prin interclasare este:


Procedura DIVIMP (T, p, q)
dac q - p 1
atunci
daca T[p] > T[q] atunci
aux T[p]
T[p] T[q]
T[q] aux
sfrit dac
altfel
m [(p+q)/2]
DIVIMP ( T, p, m)
DIVIMP (T, m+1, q)
INTERCLASARE ( T, p, q, m)
sfrit dac

sfarsit

Apelul procedurii va fi realizat prin instruciunea DIVIMP (T, 1, n).


10


Procedeul de INTERCLASARE are la baz urmtoarea idee: pornind de la 2 vectori A i B
ordonai cresctor formm un vector C care conine elementele celor doi vectori, n ordine
cresctoare.

procedura Interclasare (A, B, C, m, n, k) este
/* vectorul A are m elemente ordonate cresctor
/* vectorul B are n elemente ordonate cresctor
i 1 /* indice pentru A
j 1 /* indice pentru B
k 0 /* indice pentru C
ct timp (i m) si (j n) execut
k k+1
dac A[i] B[j] atunci
C[k] A[i]
i i+1

altfel
C[k] B[j]
j j+1
sfrit dac
sfrit ct timp
dac i > m atunci
cat timp j n execut
k k+1
C[k] B[j]
j j+1
sfrit ct timp
altfel
cat_timp i m repeta
k k+1
C[k] A[i]
i i+1
sfrit ct timp

sfrit dac
sfarsit









11

Exemplu de sortare prin interclasare
Forma iniial a vectorului
(Extras din Softul educaional Tehnici de sortare)











Exemplu de sortare prin interclasare
mprirea problemei iniiale n subprobleme i mprirea subproblemei 1
(Extras din Softul educaional Tehnici de sortare)



T 9 5 8 3 12 4 7
mparirea n subproblemele
(T[1], T[4]) i (T[5], T[7])
9 5 8 3 12 4 7
mparirea n subproblemele
(T[1],T[2]), (T[3],T[4]),
(T[5],T[6]) i (T[7])
9 5 8 3 12 4 7
Ordonare pe subprobleme
elementare
5 9 3 8 4 12 7
Interclasare pentru
subproblemele(T[1], T[4]) i
(T[5], T[7])
3 5 8 9 4 7 12
Interclasare final 3 4 5 7 8 9 12

Exemplu de sortare prin interclasare

Secvenei de mpriri a vectorului n subvectori i se poate asocia un arbore binar de cutare
n care mrcile nodurilor repreznint capetele subirurilor obinute n etape succesive de divizare.
Nodurile terminale sunt marcate cu capetele subirurilor de lungime unu. Subirurile terminale sunt
sortate. Se interclaseaz apoi irurile terminale, obinndu-se noi iruri, care sunt ulterior ordonate.
Aplicarea succesiv a procedurii de interclasare se face printr-o parcurgere n inordine a arborelui
binar asociat.

Observaie
Algoritmul metodei de sortare prin interclasare are ordinul de complexitate O (n log2 (n)).

12

Tabelul de mai jos conine implementarea n Pascal a algoritmului de sortare prin
interclasare:

Limbajul Pascal
type vector = array[1..20] of integer;
var T: vector;
i, n : integer;
procedure interclasare (var T: vector; p, q,
m: integer);
var C: vector; i, j, k: integer;
begin
i := p; j := m+1; k := 1;
while (i<=m) and (j<=q) do
if T[i] <= T[j] then begin
C[k]:=T[i]; i:=i+1; k:=k+1; end
else begin
C[k]:=T[j]; j:=j+1; k:=k+1; end;
if i <=m then
for j := i to m do begin
C[k]:=T[j]; k:=k+1; end
else
for i := j to q do begin
C[k]:=T[i]; k:=k+1; end;
k:=1;
for i := p to q do begin
T[i] := C[k]; k := k+1; end;
end;
procedure divimp(varT: vector; p,q:
integer);
var m, temp: integer;
begin
if (q-p) <= 1 then begin
if T[p] > T[q] then begin
temp:=T[p];T[p]:=T[q];
T[q]:= temp; end;
end
else begin
m := (p+q) div 2;
divimp (T, p, m);
divimp (T, m+1, q);
interclasare(T, p, q, m); end;
end;
begin
write ('nr elemente='); readln (n);
for i:=1 to n do begin
write ('T[',i,']='); readln (T[i]); end;
divimp(T, 1, n);
for i:=1 to n do write (T[i],' '); end.

13

B2. Sortarea rapid


Aceast metod de sortare se bazeaz pe tehnica Divide et Impera, la fiecare apel recursiv
fiind parcures cele trei etape specifice metodei:
Divide partiionarea problemei n mai multe subprobleme. n cazul algoritmului nostru,
partiionarea unui vector iniial T[li], , T[ls] n doi subvectori T[li], , T[k-1] i T[k+1], , T[ls]
i aducerea n T[k] a unui element ce ocup poziia final n vectorul de sortat. Cele dou
partiii au proprietatea c orice element din T[li], , T[k-1] este mai mic sau egal cu T[k] i
orice element din T[k+1], , T[ls] este mai mare sau egal cu T[k]. Indexul lui T[k] se obine n
cadrul procesului de partiionare.
Impera rezolvarea problemelor obinute la pasul anterior. Se va apela recursiv
algoritmul pentru cele dou partiii create.
Combine combinarea soluiilor obinute pentru subprobleme ntr-o soluie pentru
problema iniial. Aceast etap n cazul nostru nu mai este necesar deoarece atunci cnd
am sortat cele dou partiii deja am obinut vectorul sortat.


Conform algoritmului de mai sus, sortarea rapid are urmtoarea form:

Procedura QuiqkSort (T, li, ls)
dac li < ls atunci
Partitionare (T, li, ls, k)
QuickSort (T, li, k-1)
QuickSort (T, k+1, ls)
sfrit dac
sfrit

Apelul procedurii se va face prin instruciunea QuickSort (T, 1, n).

Procedura de partiionare trateaz o poriune din vector cuprins ntre li i ls. Rolul acestei
proceduri este de a gsi poziia k, poziie pe care elementul T[k] va rmne n vectorul sortat i, mai
mult dect att, vom avea
T[li], , T[k-1] T[k] i
T[k] T[k+1], , T[ls] .

Pentru a realiza acest lucru se folosesc dou moduri de lucru:
a). i rmne constant, j scade cu o unitate;
b). i crete cu o unitate i j rmne constant;
unde i pornete de la li iar j de la ls.

Se lucreaz astfel: ncepem cu modul de lucru a) i ct timp i < j se execut: dac T[i] > T[j] atunci se
inverseaz cele dou numere i se trece la modul de lucru b). Procedeul se repet, i i j
schimbndu-se corespunztor algoritmului. n final k va loa valoarea comun a lui i i j.
La sfritul procedeului, elementul ce se afla iniial pe poziia li va ajunge pe o poziie k (care va fi i
poziia sa final n vectorul sortat).

Datorit alternanei ntre cele dou moduri de lucru, acest procedeu poart i denumirea de
arderea lumnrii de la ambele capete.

14

Procedura de partiionare se va scrie astfel:

Procedur Partitionare (T, li, ls, k)
i1 0
j1 -1
i li
j ls
ct timp i < j execut
dac T[i] > T[j] atunci
aux T[i]
T[i] T[j]
T[j] aux
aux i1
i1 - j1
j1 - aux
sfrit dac
i i + i1
j j + j1
sfrit ct timp
k i
sfrit

Explicaii Vectorul T
mod a). i=1, j=7: 9 >7 se interschimb
i se schimb modul de lucru
9 5 8 3 12 4 7
mod b). i=2, j=7: 5 < 9
i=3, j=7: 8 < 9
i=4, j=7: 3< 9
i=5, j=7: 12 > 9 se interschimb i se
schimb modul de lucru
7 5 8 3 12 4 9
mod a). i=5, j=6: 9 > 4 se interschimb
i se schimb modul de lucru
7 5 8 3 9 4 12
mod b). i=6, j=6 s-a gsit k=6 7 5 8 3 4 9 12
mod a). i=1, j=5: 7 >4 se interschimb
i se schimb modul de lucru
7 5 8 3 4 9 12
mod b). i=2, j=5: 5 <7
i=3, j=5 8 > 7 se interschimb i se
schimb modul de lucru
4 5 8 3 7 9 12
mod a). i=3, j=4: 7 > 3 se interschimb
i se schimb modul de lucru
4 5 7 3 8 9 12
mod b). i=4, j=4 s-a gsit k=4 4 5 3 7 8 9 12
mod a). i=1, j=3: 4 > 3 se interschimb
i se schimb modul de lucru
4 5 3 7 8 9 12
mod b). i=2, j=3: 5 > 4 se interschimb
i se schimb modul de lucru
3 5 4 7 8 9 12
mod a). i=2, j=2 s-a gsit k=2 3 4 5 7 8 9 12
Vectorul sortat este: 3 4 5 7 8 9 12

Exemplu de sortare rapid
15

Observaie
Metoda de sortare rapid este eficient pentru un numr mare de date dar ineficient pentru
un vector deja sortat. Metoda consum mai putine resurse dect alte metode n multe situaii i
necesit nlog2 (n) operaii n cazul general, timpul mediu de execuie fiind de O( nlog2 (n)) i O(n
2
)
n cazul defavorabil.

Tabelul de mai jos conine implementarea n Pascal a algoritmului de sortare rapid:

Limbajul Pascal
type vector = array[1..20] of integer;
var T: vector;
i, n, k : integer;
procedure partitionare (var T: vector; li,ls:
integer; var k: integer);
var i, j, i1, j1, aux: integer;
begin
i1:=0 ; j1 := -1; i := li; j:=ls;
while (i<j) do begin
if T[i] >T[j] then begin
aux:=T[i];T[i]:=T[j];
T[j]:=aux; aux:=i1;
I1:=-j1; j1:=-aux;
end;
i:=i+i1;
j:=j+j1;
end;
k:=i;
end;
procedure quicksort(var T:vector;
li,ls:integer);
begin
if li < ls then
begin
partitionare(T,li,ls,k);
quicksort(T, li, k-1);
quicksort(T, k+1, ls);
end;
end;
begin
write ('nr elemente='); readln (n);
for i:=1 to n do begin
write ('T[',i,']='); readln (T[i]);
end;
quicksort (T, 1, n);
for i:=1 to n do write (T[i],' ');
end.
16

EXEMPLE

1. Fie un tablou unidimensional care contine n valori intregi. Realizati un program care
ordoneaza crescator elementele vectorului folosind metoda interschimbarilor directe.


Program interschimbare;
Var T: array[1..100] of integer;
n, i, j, temp : integer;
begin
write( n= ); readln(n);
for i:=1 to n do
begin
write( T[ , i , ]= ); readln(T[i]);
end;
for i:=1 to n-1 do
for j:= i+1 to n do
if T[j]<T[i] then begin
temp:=T[i]; T[i]:= T[j]; T[j]:= temp;
end;
for i:=1 to n do
write(T[i], );
end.


Se urmareste functionalitatea algoritmului pentru n=5 si T=(4,-3,5,-6,1)


1 2 3 4 5
4 -3 5 -6 1

i=1, T[1] pivot
j=2,T[2]<T[1]? (-3<4?) da T[2] T[1]

1 2 3 4 5
-3 4 5 -6 1

j=3, T[3]<T[1] (5<-3?) nu
j=4, T[4]<T[1]? (-6<-3?) da T[4] T[1]
1 2 3 4 5
-6 4 5 -3 1

j=5, T[5]<T[1]? (1<-6?) nu
i=2, T[2] pivot
j=3, T[3]<T[2] (5<4?) nu
j=4, T[4]<T[2] (-3<4?) da T[4] T[2]

1 2 3 4 5
-6 -3 5 4 1

j=5, T[5]<T[2] (1<-3?) nu
17

i=3, T[3] pivot
j=4, T[4]<T[3] (4<5?) da T[4] T[3]

1 2 3 4 5
-6 -3 4 5 1

j=5, T[5]<T[3] (1<4?) da T[5] T[3]

1 2 3 4 5
-6 -3 1 5 4
i=4, T[4] pivot
j=5, T[5]<T[4] (4<5?) da T[5] T[4]


Rezulta vectorul sortat:

1 2 3 4 5
-6 -3 1 4 5


2. Fie un tablou unidimensional care contine n valori intregi. Realizati un program care
ordoneaza crescator elementele vectorului folosind metoda bulelor.


Program bule;
Var T: array[1..100] of integer;
n, i, f,temp : integer;
begin
write( n= ); readln(n);
for i:=1 to n do
begin
write( T[ , i , ]= ); readln(T[i]);
end;
for f:=n downto 2 do
for i:= 1 to f-1 do
if T[i]>T[i+1] then begin
temp:=T[i]; T[i]:= T[i+1]; T[i+1]:= temp;
end;
for i:=1 to n do
write(T[i], );
end.
3. Fie un tablou unidimensional care contine n valori intregi. Realizati un program care ordoneaza
crescator elementele vectorului folosind algoritmul de selectie.

Program selectie;
Var T: array[1..100] of integer;
n, i, p,j,temp : integer;
begin
write( n= ); readln(n);
for i:=1 to n do
begin
18

write( T[ , i , ]= ); readln(T[i]);
end;
for i:=1 to n-1 do begin
p:=i;
for j:=i+1 to n do
if T[p]>T[j] then p:=j;
temp:=T[i]; T[i]:= T[p]; T[p]:= temp;
end;
for i:=1 to n do
write(T[i], );
end.


4. Fie un tablou unidimensional care contine n valori intregi. Realizati un program care
ordoneaza crescator elementele vectorului folosind algoritmul de insertie.


Program insertie;
Var T: array[1..100] of integer;
n, i,j,temp : integer; ok:boolean;
begin
write( n= ); readln(n);
for i:=1 to n do
begin
write( T[ , i , ]= ); readln(T[i]);
end;
for i:=2 to n do begin
temp:=T[i];j:=i-1; ok:=false;
while (j>=1) and (not ok) do
if temp <T[j] then begin
T[j+1]:= T[j]; j:=j-1;
end
else ok:=true;
T[j+1]:= temp;
end;
for i:=1 to n do
write(T[i], );
end.

PROBLEME PROPUSE

Fie un tablou unidimensional care contine n valori intregi. Realizati un program care
ordoneaza descrescator elementele vectorului folosind metoda interschimbarilor
directe.

Fie un tablou unidimensional care contine n valori intregi. Realizati un program care
ordoneaza descrescator elementele vectorului folosind metoda bulelor.