Cursos Empresas Blog Live Conf Eventos Precios

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.

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*/
void insertionSort(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 
void printArray(int arr[], int n) 
{ 
   int i; 
   for (i=0; i < n; i++) 
       printf("%d ", arr[i]); 
   printf("\n"); 
} 
  
  
  
/* Driver program to test insertion sort */
int main() 
{ 
    int arr[] = {6, 4, 3, 11, 10}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
  
    insertionSort(arr, n); 
    printArray(arr, n); 
  
    return 0; 
}

Ordenamiento por Inserción en C: Algoritmo y Ejemplo Práctico

Curso Práctico de Estructuras de Datos y Algoritmos

Clase 24 de 42

Clase 24 / 42

Ezequiel Matías Rolón Pettinari

Hace 7 años

Mi solución para C#

    class Insercion
    {
        /// <summary>
        /// La funcion InsertionSort recorre un array posición por posición y en caso de ser menor,
        /// lo coloca en la posición indicada para ordenar de menor a mayor.
        /// </summary>
        /// <param name="p_array_entrada"> El array con los elementos para ordenar</param>
        public void InsertionSort(int[] p_array_entrada) {

            //Declaracion de variables auxiliares i e j
            int i, j;

            //Variable auxiliar para almacenar el valor actual
            int valor_actual;
                        
            for ( i = 1; i < p_array_entrada.Length; i++ )
            {
                
                valor_actual = p_array_entrada[i];
                j = i - 1;

                while ( j >= 0 && p_array_entrada[j] > valor_actual)
                {
                    p_array_entrada[j + 1] = p_array_entrada[j];
                    j -= 1;

                }// Final de: while ( j >= 0 && p_array_entrada[j] < valor_actual)

                p_array_entrada[j + 1] = valor_actual;

            }// Final de: for ( i = 0; i < p_array_entrada.Length; i++ )

        }// Final de: public void InsertionSort(int [] p_array_entrada) 

        /// <summary>
        /// Funcion para recorrer el array y mostrarlo por consola.
        /// </summary>
        /// <param name="p_array_entrada"> El Array a mostrar.</param>
        public void MostrarArray( int[] p_array_entrada ) {

            // Por cada uno de los valores dentro del array de entrada
            Console.Write("- ");
            foreach (int numero in p_array_entrada)
            {
                // Mostrar por consola
                Console.Write(" {0} ",numero);
            }

            Console.WriteLine(" - ");

        }// Final de: public void MostrarArray(int[] p_array_entrada)

        /// <summary>
        /// Llama a las funciones necesarias para mostrar el array original por consola, ordenarlo y mostrar la nueva salida.
        /// </summary>
        /// <param name="p_array_entrada"> El array a ordenar</param>
        public void OrdenarConInsertionSort( int[] p_array_entrada ) {

            // Mensaje de Bienvenida
            Console.WriteLine("------------------------------------------------------------");
            Console.WriteLine("Ejercicio Platzi - Mi solución de Insertion Sort para C#.");
            Console.WriteLine("------------------------------------------------------------");
            
            // Mostrar Array original
            Console.WriteLine("Array Original:");
            MostrarArray(p_array_entrada);
            Console.WriteLine("------------------------------------------------------------");
            
            // Mostrar Array Ordenado con Insertion Sort
            Console.WriteLine("Array ordenado con Insertion Sort:");
            InsertionSort(p_array_entrada);
            MostrarArray(p_array_entrada);
            
            Console.WriteLine("------------------------------------------------------------");
            Console.WriteLine("Finalizado - ¡Nunca pares de aprender! 8) ");
            Console.WriteLine("------------------------------------------------------------");

        }// Fin de: public void OrdenarConInsertionSort()


        // Codigo para ejecutar en el main
        //
        //Insercion insercion = new Insercion();
        //int[] p_array_entrada = new int[] { 5, 10, 20, 30, 4, 3 };
        //insercion.OrdenarConInsertionSort(p_array_entrada);               
        //Console.ReadKey();


    }// Final de: class Insercion```

Comentarios (104)104 comentarios

Luis Nilson Palma Campos

Hace 8 años

Después de dos horas y mas de 3 hojas bond compilando pude entender el método insertion xd

Ricardo Celis

Profesor

`jaja lo importante es hacer lo que sea necesario para tener todo claro, saludos!

Hernán Giraldo

Algoritmo realizado con javascript y apoyado en angular para mostrar gráficamente el proceso que se llevó a cabo en el ordenamiento:

Efraín Hernández García

Te quedó súper pro!!

Eduardo Monzón

Hace 3 años

Genial, Hernán

Manuel Esteban Palacio Calderon

Samuel Hurtado marin

Me gusta mucho hacer eso en los algoritmos la primera vez que los ejecuto, para ir viendo como va todo a su sitio, lleva tiempo pero da satisfacción verlo funcionar todo.

Gloriq Lopez

gracias!! me ayudo a comprender mejor la lógica :)

David Barreto

Hace 6 años

Y la clase y la explicación??? Así no me gusta! 👎👎👎💻

Diego Reyes Cabrera

La clase de explicacion esta en Youtube :/ https://www.youtube.com/watch?v=nKzEJWbkPbQ (entendi muy bien)

Ismael López

Está es mi implementación en Python

def insertion_sort(list, n):
    for i in range(0, len(list)):
        current_value = list[i]
        position = i
        while position > 0 and list[position-1] > current_value:
            list[position] = list[position-1]
            position-=1
        list[position] = current_value
        print(f"Round {i}: {list}")

def run():
    list = [50, 83, 64, 0, 12, 46, 45, 54, 14, 78, 23, -1]
    n = len(list)
    insertion_sort(list, n)
    print(list)

if __name__ == '__main__':
    run()

John Alexander Ortiz Ramirez

Jose Antonio Rojas Ollarves

arriba roadtocode

Grecia Olympia Corona Segura

En Python

# Insertion sort algorithm in Python
# From lowest to highest

def insertion_sort(list, n):
    for i in range(1, len(list)):
        current_value = list[i]
        j = i
        while j > 0 and list[j - 1] > current_value:
            list[j] = list[j -1]
            j = j - 1
        list[j] = current_value
        print(f"Round {i}: {list}")

def run():
    list = [60, 30, 20, 10, 50, 1, 90] 
    print(list)
    n = len(list)
    insertion_sort(list, n)
    print(list)

if __name__ == "__main__":
    run()```

Jaime Andres Serrano

Ricardo Andres Rojas Alonso

Wandy Rafael Santana Evangelista

Aquí en JS:

Oliver Jesus Tuesta Yoplac

Mi código en Java:

public void insertionSort(int[] arr) {

        final int n = arr.length;

        for (int i = 1; i < n; i++) {
            final int currentValue = arr[i];
            int j = i - 1;

            while (j >= 0 && arr[j] > currentValue) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = currentValue;
            
        }

    }

Sergio Arturo Enriquez Nava

Python

def insertion_sort(lista):
    n = len(lista)
    for i in range(0, n):
        valorAct = lista[i]
        j = i
        while j > 0 and lista[j-1] > valorAct:
            lista[j] = lista[j-1]
            j -= 1
        lista[j] = valorAct


def main():
    lista = [45,65,87,9,42,1,6,0,5,-34,-266,5,21]
    print(f'\nLista original:\n\n{lista}')
    insertion_sort(lista)
    print(f'\nLista ordenada:\n\n{lista}')

if __name__ == '__main__':
    main()

Les comparto este video para reforzar los conocimientos de esta clase:

https://www.youtube.com/watch?v=lYNyL0HuWSg&ab_channel=Programaci%C3%B3nATS

Sebastián Mera

En JS💛

var list = [5,2,4,3,1]

function insertion_sort(list) {
    var j,currentVal

    for (let index = 1; index < list.length; index++) {
        currentVal=list[index]
        j=index-1
        while (j>=0 && list[j]>currentVal) {
            list[j+1] = list[j]
            j=j-1
        }
        list[j+1]=currentVal
    }
    console.log(list)
}

insertion_sort(list)

David Lara

Así como en el ejercicio anterior tengo una sola duda… en: for (i = 1; i < n; i++) { currentVal= arr[i]; j = i-1; }

No se indica en cuánto se inicia n, cómo se hace esta comparación?

María Angélica Pérez Gutiérrez

es porque n se define en la función main, como puedes ver las funciones tipo void no devuelven ningún valor, la función main que es tipo entero es el que inicializa el algoritmo y ejecuta en orden las funciones anteriores. Para no inicializar varias veces n se hace desde el main.

Usuario anónimo

User

Danelia Sanchez Sanchez

Los argumentos por defecto no están permitidos en C, son una característica de C++.

Luis Lira

Me tomó un rato entenderlo, lo que hice para comprende fue ir sustituyendo y haciendo el algoritmo primero mentalmente, haciendo eso me quedó claro cómo funciona el código

def insertion_sort(numbers):
    n = len(numbers)

    for i in range(1, n):
        current_value = numbers[i]
        j = i - 1

        while j >= 0 and numbers[j] > current_value:
            numbers[j + 1] = numbers[j]
            j -= 1

        numbers[j + 1] = current_value

    return numbers


if __name__ == "__main__":
    numbers = [6 , 4, 3, 11, 10]
    print(numbers)
    ordered_numbers = insertion_sort(numbers)
    print(ordered_numbers)

Alejandro Gonzalez Duque

freddy molleda

Tuve que tomar lapiz y papel, para recorrer el código, y una hora treinta minutos para poder comprender como funciona el algoritmo pero es gratificante cuando lo logras

Fernanda Vieira Jófili

Sí!! Muchas veces necesito escribir mi lógica en papel, así que entiendo mejor lo que necesito programar.

Ordenamiento por Inserción en C: Algoritmo y Ejemplo Práctico

Progreso del curso

Bienvenido al Curso

Introducción a los algoritmos

Algoritmos de ordenamiento

Recursividad

Divide and conquer y programación dinámica

Algoritmos 'Greedy'

Grafos y árboles

¿Cómo comparar Algoritmos?

¿Qué sigue?