slide1
Download
Skip this Video
Download Presentation
ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO

Loading in 2 Seconds...

play fullscreen
1 / 19

ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO - PowerPoint PPT Presentation


  • 139 Views
  • Uploaded on

ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO. Algoritmo che viene utilizzato per elencare gli elementi di un insieme secondo una sequenza stabilita da una relazione d'ordine, in modo che ogni elemento sia minore (o maggiore) di quello che lo segue. SELECTION SORT SELECTION SORT.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO' - powa


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide3
ALGORITMI DI

ALGORITMI DI

ORDINAMENTO

ORDINAMENTO

Algoritmo che viene utilizzato per elencare gli

elementi di un insieme secondo una sequenza

stabilita da una relazione d'ordine, in modo che

ogni elemento sia minore (o maggiore) di quello

che lo segue.

slide4
SELECTION SORT

SELECTION SORT

L'algoritmo seleziona di volta in volta il numero

minore nella sequenza di partenza e lo sposta

nella sequenza ordinata; di fatto la sequenza

viene suddivisa in due parti: la sottosequenza

ordinata,

che

occupa

dell'array, e la sottosequenza da ordinare, che

costituisce la parte restante dell'array.

le

prime

posizioni

slide5
SELECTION

SELECTIONSORT

SORT

void selsort(int x[ ],

int y) {

int z=0;

for (z=0;z

int y=0;

for (y=z+1;y

{if (x[y] < x[y]) {

int t=x[y];

x[y]=x[z];

x[z]=t;

}

}

}

Alla prima iterazione verrà selezionato

l’elemento più piccolo dell’intero

insieme e sarà scambiato con quello

che occupa la prima posizione.

Alla seconda iterazione è selezionato il

secondo elemento più piccolo

dell’insieme è viene scambiato con

l’elemento che occupa la seconda

posizione.

Si ripete fino ad aver collocato nella

posizione corretta tutti gli n elementi.

slide6
INSERTION SORT

INSERTION SORT

L'algoritmo solitamente ordina la sequenza sul

posto. Si assume che la sequenza da ordinare

sia partizionata in una sottosequenza già

ordinata,

all'inizio

composta

elemento, e una ancora da ordinare.

da

un

solo

slide7
INSERTION

INSERTIONSORT

SORT

Ad ogni iterazione, il vettore è

costituito da una parte iniziale

ordinata e da la parte rimanente

che contiene i valori da ordinare.

Per ogni valore ancora da inserire,

viene fatta una ricerca binaria

nella parte ordinata del vettore e

vengono spostati in avanti tutti gli

elementi per liberare una posizione

Nella posizione liberata viene

inserito il valore.

void inssort(int a[ ] ,int n) {

int i=0,j=0;

for (i=1;i

int x=a[i], s=1, d=i-1;

while (s<=d) {

int m=(s+d)/2; if (x

else s=m+1;

}

for (j=i-1,j>=s;j--) a[j+1]=a[j];

a[s]=x;

}

}

slide8
BUBBLE SORT

BUBBLE SORT

Il suo funzionamento è semplice: ogni coppia di

elementi adiacenti della lista viene comparata

e se essi sono nell'ordine sbagliato vengono

invertiti. L'algoritmo scorre poi tutta la lista

finché non vengono più eseguiti scambi,

situazione che indica che la lista è ordinata.

slide9
BUBBLE SORT

BUBBLE SORT

void bubbsort(int x[ ], int

y) {

bool scambio=true;

int ultimo=y-1,i=0;

while (scambio) {

scambio=false;

for (i=0;i

if ( x[i]> x[i+1]) {

int t= x[i];

x[i]=x[i+1];

x[i+1]=t;

scambio=true;

}

}

ultimo --;

}

}

L’algoritmo BUBBLE SORT

(ordinamento a bolle) so basa

sull’idea di

far emergere pian piano gli

elementi più piccoli verso l’inizio

dell’insieme da ordinare facendo

sprofondare gli elementi maggiori

verso il fondo: un po’ come le

bollicine in un bicchiere di acqua

gassata da qui il nome di

ordinamento a bolle.

slide10
QUICK SORT

QUICK SORT

L'idea base può esprimersi agevolmente in

termini ricorsivi. Ad ogni stadio si effettua un

ordinamento parziale di una sequenza di oggetti

da

ordinare.

Assunto

perno dello stadio, si confrontano con esso gli

altri elementi e si posizionano alla sua sinistra i

minori e a destra i maggiori, senza tener conto

del loro ordine. Dopo questo stadio si ha che

il perno è nella sua posizione definitiva.

un

elemento

come

slide11
QUICK SORT

QUICK SORT

void sort(int a[ ], int inizio, int fine)

{

int x, y, z;

if (fine >inizio) {

x = a [inizio];

y= inizio + 1;

z= fine+1;

while (y < z) {

if (a [y] < x) y++;

else {

r--;

swap(a[y], a[z]);

}

void swap(int & x, int & y) {

int temp=x;

x=y;

y=temp;

}

Assunto un elemento come perno, si

confrontano con esso gli altri elementi e si

posizionano alla sua sinistra i minori e a

destra i maggiori, senza tener conto del loro

ordine. Dopo questo stadio si ha che il perno

è nella sua posizione

definitiva. Successivamente si procede in

modo ricorsivo all'ordinamento parziale delle

sottosequenze di elementi rimasti non

ordinati, fino al loro esaurimento.

slide12
MERGE SORT

MERGE SORT

Le due sottosequenze ordinate vengono fuse.

Per fare questo, si estrae ripetutamente il

minimo delle due sottosequenze e lo si pone

nella sequenza in uscita, che risulterà ordinata.

slide13
MERGE SORT

MERGE SORT

void mersort (int x[ ], int sinistra,

int centro, int destra)

int i = sinistra, j=centro+ 1,k=0;

int y[ ];

while ((i <= centro) && (j <= destra))

{

if (x[i] <= x[j]){

y[k]=a[i];

i=i + 1;

} else {

y[k] = x[j];

j=j + 1; }

k=k + 1;

}

for (k =left ;k

a[k] = b[k - left];}

void mergesort (int[] a, int

left, int right) {

int center;

if (left < right) {

center = (left + right) / 2;

mergesort(a, left, center);

mergesort(a, center+1, right);

merge(a, left, center, right);

}

slide14
HEAP SORT

HEAP SORT

In

ordinare ad esempio un array in senso crescente)

ogni nodo padre contiene un valore maggiore o

uguale a quello dei suoi due figli diretti, di

conseguenza risulterà maggiore anche di tutti i

nodi che si trovano nel sottoalbero di cui esso è la

radice; questo non implica affatto che nodi a

profondità maggiore contengano valori minori di

quelli a profondità minore.

uno

mucchio

decrescente

(utilizzato

per

slide15
HEAP SORT

HEAP SORT

void HeapSort(int a[ ], int n){

int i;

int lh = n;

Costruisci_Heap(a, n);

for(i = n-1; i > 0; i--){

temp = a[i];

a[i] = a[0];

a[0] = temp;

lh--;

Rendi_Heap(a, n, lh, 0); }

}

slide16
COUNTING SORT

COUNTING SORT

L'algoritmo conta il numero di occorrenze di

ciascun valore presente nell'array da ordinare,

memorizzando questa informazione in un array

temporaneo di dimensione pari all'intervallo di

valori. Il numero di ripetizioni dei valori

inferiori

indica

la

posizione

immediatamente successivo.

del

valore

slide17
COUNTING SORT

COUNTING SORT

void counting_sort(int* A,int Alen,int* B,int k){

int i;

int C[k];

for(i=0; i

C[i] = 0;

int j;

for(j=0; j

C[A[j]] = C[A[j]]+1;

for(i=1; i

C[i] = C[i]+C[i-1];

for (j=Alen-1; j>=0; j--){

B[C[A[j]]-1] = A[j];

C[A[j]] = C[A[j]]-1;

}

}

Per ogni elemento x dell'insieme da

ordinare si determinano quanti elementi

sono minori di x, si usa questa

informazione per assegnare ad x la sua

posizione finale nel vettore ordinato. Se,

ad esempio, vi sono 8 elementi minori di

x, allora x andrà messo nella posizione 9

bisogna fare attenzione al caso in cui vi

siano elementi coincidenti. In questo

caso infatti non vogliamo assegnare a

tutti la stessa posizione.

slide18
BUCKET SORT

BUCKET SORT

L'algoritmo conta il numero di occorrenze di

ciascun valore presente nell'array da ordinare,

memorizzando questa informazione in un array

temporaneo di dimensione pari all'intervallo di

valori. Il numero di ripetizioni dei valori

inferiori

indica

la

posizione

immediatamente successivo.

del

valore

slide19
BUCKET SORT

BUCKET SORT

void bucketSort(int array[ ], int n) {

int i, j;

int count[n];

for(i=0; i < n; i++) {

count[i] = 0;

}

for(i=0; i < n; i++) {

(count[array[i]])++;

}

for(i=0,j=0; i < n; i++) {

for(; count[i]>0; (count[i])--) {

array[j++] = i;

}}}

int main() {

int array[] = {1,3,4,6,4,2,9,1,2,9};

int n = 10; int i;

for (i = 0;i < n;i++) {

printf("%d ", array[i]); }

printf("\n");

bucketSort(array, n);

for (i = 0;i < n;i++) {

printf("%d ", array[i]); }

printf("\n");

Il concetto che sta alla base

dell’algoritmo è quello di dividere

l’intervallo in n sottointervalli della

stessa dimensione, detti bucket, nei

quali vengono distribuiti gli n valori

di input. A questo scopo lo

pseudocodice che definisce

l’algoritmo suppone che l’input sia

un array A di n elementi e richiede

un array ausiliario B[0...n−1] di liste

concatenate (bucket). L’algoritmo

procede semplicemente ordinando i

valori in ogni bucket tramite un

ordinamento di tipo insertion sort.

ad