1 / 18

Algoritmos para Ordenar datos

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

schuyler
Download Presentation

Algoritmos para Ordenar datos

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Algoritmos para Ordenar datos

  2. 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:

  3. 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)

  4. 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… } }

  5. 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)

  6. 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

  7. 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 } (n2-n)/2 arreglo[minj]=arreglo[i]; (n-1) arreglo[i]=minx; (n-1) } //Fin ciclo externo (n-1) } Orden: O(n2)

  8. 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)

  9. 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

  10. 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

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

  12. 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

  13. 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

  14. 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

  15. MergeSort: Fase de Mezcla 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

  16. 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]; }

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

  18. 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

More Related