!

  Ordinare un vettore di informazioni significa

effettuare una permutazione in modo da
rispettare una relazione d’ordine tra gli elementi
del vettore

!   Il tipo base del vettore deve essere un tipo

ordinato (su cui si possono usare gli operatori di
relazione <, <=, >, >=)
!   La caratteristica dominante dell’algoritmo è lo
scambio di due elementi.
!   Il metodo consiste nel confrontare coppie di
elementi adiacenti ed effettuare uno scambio nel
caso in cui gli elementi non siano in ordine, fino a
che tutti gli elementi siano ordinati
!   Si effettuano diverse scansioni degli elementi del
vettore: ad ogni passo si confronta ogni elemento
A[j] con l’elemento adiacente A[ j+1] e si effettua
uno scambio nel caso in cui risulti A[ j+1] < A[ j ].
Inizialmente j deve variare tra 1…n-1; nel passo
successivo tra 1…n-2; nell’ultimo passo tra 1..2
!   Si può quindi introdurre un indice i che ad ogni
passo definisca qual è l’ultimo valore di j
!   Se consideriamo il vettore in posizione verticale
e gli elementi come delle bollicine in un
contenitore d’acqua, con pesi diversi a seconda
del valore degli elementi, ad ogni passo
possiamo immaginare che salga a galla
l’elemento leggero tra quelli considerati
 n=5

111 11 11 222 22 22 333 33 33 44444 44 555

55 55
10
14
14
14
25 10
10 8 816
1010
16
16
25
141481014 8
10
16814
10
14
10
16
25 8
8 168
16
16
25
816
10
16 1625258
25
25
825
25
25
j jj j j j j+1
ij+1j jj i j+1
jj+1 jji j+1
ij+1
j+1 i iij ii
j+1 i j+1 j+1i
j+1j+1 j+1 j+1
j+1 Itera per i che varia da n a 2
Itera per j che varia da 1 a i-1
Se A[ j ] > A[j + 1]
Allora Scambia A[ j+1] e A[ j ];
function [vett_ord]=bubble_sort(vettore)
disp(vettore);
num_el=numel(vettore);
i = 0;
j = 0;
temp = 0;
for i=num_el:-1:2
for j=1:1:i-1
if (vettore(j) > vettore(j+1))
temp = vettore(j);
vettore(j) = vettore(j+1);
vettore(j+1) = temp;
end
end
end
vett_ord=vettore;
end
n=5

1
1 2
2 3
3 4
3
4 5
5
8
10 10 8
14
10 4
14
16 16
10
8 10 25
25
25 8 25
14 14
25 25
16
ii i min
min
ii ii
min
min sup
sup
inf
inf inf inf
inf inf
inf min
function [v_ord]=select_sort(vettore)
disp(vettore);
i = 1;
temp = 0;
indiceMinimo=1;
array_len=numel(vettore);
for i=1:1:array_len
indiceMinimo = trova_min(vettore, i, array_len);
[vettore(i), vettore(indiceMinimo)] = scambia
( vettore(i),vettore(indiceMinimo));
end
v_ord=vettore;
end