Como ordenar

1. PROYECTO FINAL DE
UTILITARIOS
Programacion
Autor: Daniel Guaycha

2. Metodos de
Ordenamiento

3. Los algoritmos de ordenamiento no permiten, como su nombre mismo lo dice, ordenar.
En este caso nos servirán para ordenar vectores o matrices con valores asignados
Aleatoriamente. Nos centraremos en los métodos mas populares analizando la cantidad
De comparaciones que suceden, el tiempo que demora y revisando el codigo, escrito
En c++

4. ¿Que son los Algoritmos de Ordenamiento?
Es un algoritmo que pone elementos de una lista o un
vector en una secuencia dada por una relación de
orden

5. ORDENAMIENTO BURBUJA
Bubble Sort
Funciona revisando cada elemento de la lista que va a ser
ordenada con el siguiente, intercambiándolos de posición si están
en el orden equivocado. Es necesario revisar varias veces toda la
lista hasta que no se necesiten más intercambios, lo cual significa
que la lista está ordenada

6. ORDENAMIENTO POR INSERCION
Inicialmente toma un primer elemento y lo comparo con los demas,
desplazándose hasta que quede en su posición final. Continúa
haciendo esto, insertando cada elemento en la posición que le
corresponde, hasta que las tengo todos en orden.

7. Quicksort
Este es un algoritmo de ordenamiento rapido, que lo que hace es
elejir un pivote y luego resituar los demás elementos de la lista a
cada lado del pivote, de manera que a un lado queden todos los
menores que él,

8. for (int pasada=0; pasada<n-1 && bandera==1;pasada++)
{
bandera=0;
for (int j=0; j<n-pasada-1;j++)
{if (numeros[j]> numeros[j+1])
{ bandera=1;
mantiene=numeros[j];
numeros[j]=numeros[j+1];
numeros[j+1]=mantiene;
}
}
ORDENAMIENTO BURBUJA: ESTRUCTURA

9. ORDENAMIENTO POR INSERCION
int main() {
const int n=10;
int num[n]={90, 2, 8, 5, 1, 9, 70, 3, 91, 4.};
int i,j;
int aux;
for (int i=1;i<n; i++){
j=i;
aux=num[i];
while(j>0 && aux<num[j-1]){
num[j]=num[j-1];
j--;
}
num[j]=aux;
}
for(int a=0; a<n; a++){
cout<<""<<num[a]<<" ";
}
return 0;
}

10. ORDENAMIENTO QUICKSORT : ESTRUCTURA
main(){
int izq,der,temporal,pivote;
izq=lim_izq;
der=lim_der;
pivote=num[(izq+der)/2];
do{
● Se elige un pivote.
● Se reubican los elementos respecto al pivote los
menores antes, los mayores atrás.
● El arreglo queda separado en dos subarreglos
● Se repite el proceso con los subarreglos
resultantes
● El arreglo esta ordenado
while(num[izq]<pivote && izq<lim_der)izq++;
while(pivote<num[der]&& der>lim_izq)der--;
if(izq<=der){
temporal=num[izq];
num[izq]=num[der];
num[der]=temporal;
izq++;
der--;
}
}while(izq>=der);
if(lim_izq<der){qs(num,lim_izq,der);}
if(lim_der>izq){qs(num,lim_der,izq);}
}