Algoritmi di algoritmi di ordinamento ordinamento
Sponsored Links
This presentation is the property of its rightful owner.
1 / 19

ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO PowerPoint PPT Presentation


  • 106 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO

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


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

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


SELECTION

SELECTIONSORT

SORT

void selsort(int x[ ],

int y) {

int z=0;

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

int y=0;

for (y=z+1;y<n;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.


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


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<n;i++) {

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

while (s<=d) {

int m=(s+d)/2; if (x<a[m]) d=m-1;

else s=m+1;

}

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

a[s]=x;

}

}


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.


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<ultimo;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.


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


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.


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.


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<right;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);

}


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


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); }

}


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


COUNTING SORT

COUNTING SORT

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

int i;

int C[k];

for(i=0; i<k; i++)

C[i] = 0;

int j;

for(j=0; j<Alen; j++)

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

for(i=1; i<k; 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.


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


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.


  • Login