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

ALGORITMI DI ALGORITMI DI ORDINAMENTO ORDINAMENTO PowerPoint PPT Presentation


  • 95 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

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.


Algoritmi di algoritmi di ordinamento ordinamento

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


Algoritmi di algoritmi di ordinamento ordinamento

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.


Algoritmi di algoritmi di ordinamento ordinamento

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


Algoritmi di algoritmi di ordinamento ordinamento

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;

}

}


Algoritmi di algoritmi di ordinamento ordinamento

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.


Algoritmi di algoritmi di ordinamento ordinamento

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.


Algoritmi di algoritmi di ordinamento ordinamento

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


Algoritmi di algoritmi di ordinamento ordinamento

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.


Algoritmi di algoritmi di ordinamento ordinamento

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.


Algoritmi di algoritmi di ordinamento ordinamento

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

}


Algoritmi di algoritmi di ordinamento ordinamento

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


Algoritmi di algoritmi di ordinamento ordinamento

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

}


Algoritmi di algoritmi di ordinamento ordinamento

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


Algoritmi di algoritmi di ordinamento ordinamento

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.


Algoritmi di algoritmi di ordinamento ordinamento

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


Algoritmi di algoritmi di ordinamento ordinamento

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