Algoritmos para Ordenar datos

Algoritmos Básicos Burbuja Burbuja mejorado Sort de Selección Sort de Inserción Luego se verán algoritmos más eficientes, se comienza con el método de la burbuja:

Burbuja void burbuja(int *arreglo, int n) { int aux,i,j; 1 for(i=0;i<n-1;i++){ (n-1)+1 for(j=0;j<n-i-1;j++){ (n2-n)/2 + (n-1) if(arreglo[j] > arreglo[j+1]){ (n2-n)/2 aux=arreglo[j]; (n2-n)/2 arreglo[j]=arreglo[j+1]; (n2-n)/2 arreglo[j+1]=aux; (n2-n)/2 } (n2-n)/2 } (n2-n)/2 } n-1 } Orden: O(n2)

Burbuja Mejorado void burbujaMejorado(int *arreglo, int n) { int aux,i,j,bandera; for(i=0;i<n-1;i++){ bandera=0; for(j=0;j<n-i-1;j++){ if(arreglo[j] > arreglo[j+1]){ aux=arreglo[j]; arreglo[j]=arreglo[j+1]; arreglo[j+1]=aux; bandera=1; } if(bandera==0) break; //Si no hubo intercambios, terminar…

Burbuja Mejorado Constituye una mejora ya que el algoritmo termina inmediatamente cuando los datos ya están ordenados Detecta que los datos ya están ordenados porque no se producen intercambios (bandera =0 al terminar el ciclo interno) Sigue siendo O(n2) (Peor caso)

Sort Selección void select(int *arreglo, int n) { int minj, minx; 1 for(int i=0; i<n-1; i++) (n-1)+1 minj=i; (n-1) minx=arreglo[i]; (n-1) Continúa

for(int j=i+1; j<n; j++) (n2-n)/2 + (n-1) { if(arreglo[j]<minx) (n2-n)/2 minj=j; (n2-n)/2 minx=arreglo[j]; (n2-n)/2 } (n2-n)/2 arreglo[minj]=arreglo[i]; (n-1) arreglo[i]=minx; (n-1) } //Fin ciclo externo (n-1) } Orden: O(n2)

Sort de Inserción void sortInsercion( int v[], int n ) { int x, j; 1 for(int i=1; i<n; i++) (n-1)+1 x=v[i]; (n-1) j=i-1; (n-1) while( (j>=0)&&(v[j]>x) ) (n2-n)/2 + (n-1) v[j+1]=v[j]; (n2-n)/2 j=j-1; (n2-n)/2 } (n2-n)/2 v[j+1]=x; (n-1) } (n-1) } Orden: O(n2)

Algoritmos eficientes para Ordenamiento A continuación se verán 2 algoritmos cuyo orden de magnitud promedio es O(nlog2n) siendo este el mejor orden que se logra en algoritmos de ordenamiento Los algoritmos son: - QuickSort (Ordenamiento rápido) - MergeSort (Ordenamiento por mezcla) Los algoritmos de Shell y HeapSort (entre otros) también logran este mismo orden

Quicksort La idea básica del algoritmo es seleccionar un elemento cualquiera como pivote. Se colocan a la izquierda del pivote todos los elementos que son menores que él y a su derecha todos los que son mayores. Tanto con el grupo de elementos que quedó a la izquierda como con el grupo de la derecha se invoca de nuevo el algoritmo de Quicksort y se repite el proceso hasta lograr el ordenamiento

QuickSort #include <iostream.h> void Quicksort (int *v, int Izq, int Der) { int i=Izq, j=Der, aux; int Pivote=v[(Izq + Der)/2]; do{ while (v[i] < Pivote) i++; while (v[j] > Pivote) j--; if (i<=j){ aux=v[i]; v[i]=v[j]; v[j]=aux; i++; j--; } }while(i<=j); if(j>Izq) Quicksort (v, Izq,j); if(i<Der) Quicksort (v, i, Der);

QuickSort void main(void) { int vec[5]={6,4,3,8,1}; Quicksort(vec,0,4); for(int k=0;k<5;k++) cout<< vec[k] << endl; } Imprimió: 1,3,4,6,8

MergeSort El algoritmo tiene 2 fases: Partición: Se divide sucesivamente la lista de elementos a ordenar en listas más pequeñas hasta llegar a listas de un solo elemento Mezcla: Se comienzan a mezclar las listas de un elemento para formar listas ordenadas de 2 elementos, luego se mezclan las listas de 2 elementos para formar listas de 4 elementos ordenadas y así sucesivamente hasta terminar

MergeSort: Fase de partición Ejemplo: Ordenar 3, 2, 6, 1, 13, 4, 21, 7 3, 2, 6, 1, 13, 4, 21, 7 3, 2, 6, 1 13, 4, 21, 7 13, 4 21, 7 3, 2 6,1 3 2 6 1 13 4 21 7

MergeSort: Fase de Mezcla Final 1,2,3,4,6,7,13,21 1,2,3,6 4,7,13,21 Mezcla Mezcla 4,13 7,21 2,3 1,6 Mezcla Mezcla Mezcla Mezcla 3 2 6 1 13 4 21 7

MergeSort #include <iostream.h> void mezcla(int *v, int izq,int dcha, int centro) { int x=izq,y=centro+1,z=x; //Vector auxiliar para realizar la mezcla int aux[100]; while (x <= centro && y <= dcha){ if(v[x]<v[y]) { aux[z]= v[x]; x++;} else { aux[z]= v[y]; y++;} z++; } //Terminar de pasar elementos faltantes while (x<=centro){ aux[z]=v[x]; x++;z++;} while (y<=dcha){ aux[z]=v[y]; y++;z++;} //Copiar aux en v for(x=izq; x<=dcha;x++) v[x] = aux[x];

MergeSort void Mergesort (int *v, int primero, int ultimo) { int central; if(primero < ultimo ){ central = (primero + ultimo)/2; Mergesort(v,primero,central); Mergesort(v,central+1,ultimo); mezcla(v,primero,ultimo,central); }

MergeSort void main(void) { int vec[5]={5,1,33,12,11}; Mergesort(vec,0,4); for(int k=0;k<5;k++) cout<< vec[k] << endl; } Imprimió: 1,5,11,12,33