1

## ¿Qué es un algoritmo de ordenamiento?

¿Qué es un algoritmo de ordenamiento?

Un algoritmo de ordenamiento colocará los objetos - números y letras- en orden. Será muy útil para índices por ej.

Vamos a obtener un arreglo ordenado, es un arreglo que tiene un orden específicamente definido. Por ej. [a, b, c, d] es un arreglo ordenado alfabéticamente. [1, 2, 3, 4, 5] es un arreglo de números enteros ordenados ascendentemente.

Algoritmos más utilizados

Merge Sort

Utiliza un principio que es divide y vencerás, se separa en partes para resolver problemas individuales, y es relativamente rápido. Al final que hace la fusión de los datos en el orden correcto, es más útil para cuando se tiene muchos datos.

Insertion Sort

Se va comparando valores y se va colocando del lado izquierdo, cada vez que se va llegando un valor nuevo. Se utilizar cuando tu set de datos es corto.

Insertion Sort es un algoritmo simple que ordena individualmente cada valor, como lo harías al ordenar un set de cartas del juego UNO en tu mano.

https://s3-us-west-2.amazonaws.com/secure.notion-static.com/b360a646-e9fd-4454-bda5-36697d6250d3/InsertionSort-4c42140c-3190-4a77-b5d2-1a550a0653da.jpg

Como puedes observar en la imagen, recorremos nuestro set de datos posición por posición y comparamos el número con los valores anteriores, en caso de ser menor, lo colocamos en su posición indicada para ordenar de menor a mayor.

#include<stdio.h>#include<math.h>/* Función de insertion Sort*/voidinsertionSort(int arr[], int n){ 
   int i, currentVal, j; 
   for (i = 1; i < n; i++) 
   { 
       currentVal= arr[i]; //obtenemos el valor actual a comparar
       j = i-1;
  
       /* mueve los elementos del arreglo arr[0..i-1],que son mayores que el valor de la posición actual del recorrido, a una posición adelante de su posición actual */while (j >= 0 && arr[j] > currentVal) 
       { 
           arr[j+1] = arr[j]; 
           j = j-1; 
       } 
       arr[j+1] = currentVal; 
   } 
} 
  
// función auxiliar para imprimir un arrary de tamaño n voidprintArray(int arr[], int n){ 
   int i; 
   for (i=0; i < n; i++) 
       printf("%d ", arr[i]); 
   printf("\n"); 
} 
  
  
  
/* Driver program to test insertion sort */intmain(){ 
    int arr[] = {6, 4, 3, 11, 10}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
  
    insertionSort(arr, n); 
    printArray(arr, n); 
  
    return0; 
}

Buble Sort

Es un algoritmo básico, va ordenando de pares y dejando al menor primero, es un lento. Es el algoritmo más básico que existe. Y funciona cambiando las celdas adyacentes en caso de que no estén ordenadas y va de par en par. en caso de que alguna celda este en el orden incorrecto haría un intercambio (swapping en inglés).

<h3>Pasos de implementación</h3>
  1. Comenzamos a realizar la comparación de elementos adyacentes.
  2. Repetimos hasta tener una pasada completa sin ningún swapping (intercambio).
#include<stdio.h>//Función de cambiar de posiciónvoidcambiar_pos(int *n1, int *n2){
    //n1 es el nro mayor y n2 el nro menor, int es la variable temporal.int temp = *n1; 
    *n1 = *n2;
    *n2 = temp;
}

//Siguiente función, que se encargará del ordenamiento, los datos que se van a necesitar son son el array "S", de nros a ordenar es decir, "N" que son los caracteres a ordenar.voidbubleSort(int vector_entrada[], int n){
    int i, j; // "j" es un auxiliar de los datos que tenemos para comparar. "i" es la posición del vector actual, del recorrido principal.// "n" es el nro total de datos, son las posiciones comenzando desde cero.//son los ciclos totalesfor(i=0; i < n-1; i++)
    {
        //vamos a tener cada una de las posiciones del vector, a i se le resta uno para comenzar en la posición previa.for(j=0; j < n-i-1; j++)
        {
            //[10, 5, 3, 333]if(vector_entrada[j]>vector_entrada[j+1])
            cambiar_pos(&vector_entrada[j],&vector_entrada[j+1]);
        }
    }

}

intprint_array(int vector_entrada[], int n){
    int i;
    for(i = 0; i<n-1; i++)
    {
        //La coma para que sea como una sola linea.printf("%d   ,", vector_entrada[i]);
        printf("\n fin del ordenamiento");
    }
}

intmain(){
    int vector_entrada[] = {100, 1992, 0, 5, -1, 60, 70, 15, 14, 10};
    int n = sizeof(vector_entrada)/ sizeof(vector_entrada[0]); //divición entre tamaño de todo el vector de entrada por un valor individual del vector.
    bubleSort(vector_entrada, n);
    print_array(vector_entrada, n);
    printf("\n");

   return0; 
}

-1   ,
 fin del ordenamiento0   ,
 fin del ordenamiento5   ,
 fin del ordenamiento10   ,
 fin del ordenamiento14   ,
 fin del ordenamiento15   ,
 fin del ordenamiento60   ,
 fin del ordenamiento70   ,
 fin del ordenamiento100   ,
 fin del ordenamiento

Quick Sorte

Divide el problema en dos y resuelve el problema. Depende siempre del set de datos.


S: secuencia de objetos ordenables. Números a ordenar.

N: es el no de elementos a ordenar S. El nro de elementos en nuestra secuencia.

Escribe tu comentario
+ 2