Algoritmos de Ordenamiento Descendente: Implementación Práctica

Clase 25 de 42 • Curso Práctico de Estructuras de Datos y Algoritmos

Contenido del curso

Bienvenido al Curso

1
Algoritmos y Estructuras de Datos: Curso Básico
02:17 min

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?

41
Comparación de Algoritmos: Complejidad y Ritmo de Crecimiento
11:14 min

¿Qué sigue?

42
Resolución de Problemas Básicos con Algoritmos y Estructuras de Datos
02:26 min

Tomar examen

¡Hola! en esta lectura quiero animarte a realizar el siguiente desafío: implementa un algoritmo de ordenamiento que sea capaz de ordenar de mayor a menor el set de datos dado, comparte tus resultados en la sección de comentarios, ¡comparte el código que utilizaste también!

-796 3229 -5164 -362 4408 8965 -6068 9329 -3034 -443 -6693 9497 2615 -5966 -9065 -1160 6148 5517 1123 -8887 5649 3302 -1176 -8542 -9166 8 -2906 8987 -2414 -7984 4410 8872 5241 -4556 59 -5562 -3877 7452 -4467 2076 4076 4297 -3847 -2055 4483 -1484 -2371 6199 -7261 -7032 6010 2325 -6625 -2601 3870 1822 -5665 9622 9883 -5794 -5218 2926 8599 -3099 6399 -2570 3943 -2409 5114 9791 -4420 1065 3077 -1062 -8004 4397 1635 8578 -9226 9222 -1793 -2691 -5060 -4727 -4098 946 -6558 -4111 4575 -2685 -4729 -5277 1936 5106 -2089 824 9421 -1683 -2083 7891 -2099 1305 -9076 -3535 2565 -2871 9448 7177 -8614 -9954 -362 1455 -8834 -9846 -8412 1175 -1981 -5991 7201 -1997 -5156 -1634 -9803 1032 9551 -6153 8502 3536 -2980 8681 -9210 4408 8780 -916 -369 -8651 1246 -702 -5555 23 8208 2037 6941 9545 -5147 5063 -8358 2772 8553 9885 4624 -3576 9131 1229 -429 -479 -673 -7060 -4031 5650 6679 6796 5622 -6256 -238 -6096 3096 -1610 -2948 6291 -1666 5219 5850 7387 -3260 3672 -1766 -9941 8252 2649 7079 -8026 6356 676 -5065 -6338 3287 680 -3269 2770 6637 -8744 9162 -2204 -3066 -7228 8762 1505 4957 766 -9136 4632 -5022 -9999 5361 2732 7831 -501 -4650 7236 3682 -2438 5574 -8230 -9669 -7442 7966 -2905 7629 7137 200 -8670 -749 2228 458 7889 -3668 -5350 -3261 6741 -6953 4800 3372 6662 -1018 8523 3164 3577 9720 -6826 -1574 -7875 -2796 -1078 -4755 4926 3368 4302 9254 6410 -4689 7878 2461 8233 -6688 5904 4735 -2940 8830 9976 -3674 4222 -1446 6187 -3181 -8882 5487 -6939 -7885 3786 -6234 -1062 -4553 -5709 8459 5008 3352 6586 537 -7610 3261 8246 -2105 5107 7957 -7886 -2925 -2541 -7449 9521 5073 -239 -8054 -4379 -8323 -6485 -4828 -5294 -2720 595

#include <stdio.h>
#define SIZE 300

void swap(int *n1, int *n2)
{
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}

void selectionSort(int array[], int n) 
{
    int index, maximum;
    for(int i = 0; i < n; i++) 
    {
        index = i;
        maximum = array[i];
        for(int j = index + 1; j < n; j++)
        {
            if(array[j] > maximum) {
                index = j;
                maximum = array[j];
            }
        }
        swap(&array[index], &array[i]);
    }
}

void print_array(int array[], int n)
{
    for(int i = 0; i < n; i++)
        printf("%d ", array[i]);
    printf("\n");
}

int main() 
{
    FILE *archivo;
    int arr[SIZE];
    archivo = fopen("numbers.dat", "rb"); // abrir archivo en modo lectura

    if(archivo != NULL) // si se abrió el archivo
    {
        for(int i = 0; i < SIZE; i++)
            fscanf(archivo, "%d", &arr[i]); // leer datos del archivo
    
        fclose(archivo); // cerrar el archivo

        selectionSort(arr, SIZE);
        print_array(arr, SIZE);
    } 
    else
        printf("No se leyo el archivo");
    
    return 0;
}

#include <stdio.h>

void swap(int *n1, int *n2)
{
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}

void selectionSortMinor(int S[], int n)
{
    int i, j, minor;
    for (i = 0; i < n; i++)
    {
        minor = i;
        for (j = i; j < n; j++)
        {
            if (S[j] < S[minor])
                minor = j;
        }
        swap(&S[i], &S[minor]);
    }
}

void selectionSortGreater(int S[], int n)
{
    int i, j, greater;
    for (i = n - 1; i >= 0; i--)
    {
        greater = i;
        for (j = i; j >= 0; j--)
        {
            if (S[j] < S[greater])
                greater = j;
        }
        swap(&S[i], &S[greater]);
    }
}

void print(int S[], int n)
{
    int i;
    for (i = 0; i < n; i++)
        printf("%d,  ", S[i]);
    printf("\n");
}

int main(int argc, char const *argv[])
{
    int intArray[] = {-796, 3229, -5164, -362, 4408, 8965, -6068, 9329, -3034, -443, -6693, 9497, 2615, -5966, -9065, -1160, 6148, 5517, 1123, -8887, 5649, 3302, -1176, -8542, -9166, 8, -2906, 8987, -2414, -7984, 4410, 8872, 5241, -4556, 59, -5562, -3877, 7452, -4467, 2076, 4076, 4297, -3847, -2055, 4483, -1484, -2371, 6199, -7261, -7032, 6010, 2325, -6625, -2601, 3870, 1822, -5665, 9622, 9883, -5794, -5218, 2926, 8599, -3099, 6399, -2570, 3943, -2409, 5114, 9791, -4420, 1065, 3077, -1062, -8004, 4397, 1635, 8578, -9226, 9222, -1793, -2691, -5060, -4727, -4098, 946, -6558, -4111, 4575, -2685, -4729, -5277, 1936, 5106, -2089, 824, 9421, -1683, -2083, 7891, -2099, 1305, -9076, -3535, 2565, -2871, 9448, 7177, -8614, -9954, -362, 1455, -8834, -9846, -8412, 1175, -1981, -5991, 7201, -1997, -5156, -1634, -9803, 1032, 9551, -6153, 8502, 3536, -2980, 8681, -9210, 4408, 8780, -916, -369, -8651, 1246, -702, -5555, 23, 8208, 2037, 6941, 9545, -5147, 5063, -8358, 2772, 8553, 9885, 4624, -3576, 9131, 1229, -429, -479, -673, -7060, -4031, 5650, 6679, 6796, 5622, -6256, -238, -6096, 3096, -1610, -2948, 6291, -1666, 5219, 5850, 7387, -3260, 3672, -1766, -9941, 8252, 2649, 7079, -8026, 6356, 676, -5065, -6338, 3287, 680, -3269, 2770, 6637, -8744, 9162, -2204, -3066, -7228, 8762, 1505, 4957, 766, -9136, 4632, -5022, -9999, 5361, 2732, 7831, -501, -4650, 7236, 3682, -2438, 5574, -8230, -9669, -7442, 7966, -2905, 7629, 7137, 200, -8670, -749, 2228, 458, 7889, -3668, -5350, -3261, 6741, -6953, 4800, 3372, 6662, -1018, 8523, 3164, 3577, 9720, -6826, -1574, -7875, -2796, -1078, -4755, 4926, 3368, 4302, 9254, 6410, -4689, 7878, 2461, 8233, -6688, 5904, 4735, -2940, 8830, 9976, -3674, 4222, -1446, 6187, -3181, -8882, 5487, -6939, -7885, 3786, -6234, -1062, -4553, -5709, 8459, 5008, 3352, 6586, 537, -7610, 3261, 8246, -2105, 5107, 7957, -7886, -2925, -2541, -7449, 9521, 5073, -239, -8054, -4379, -8323, -6485, -4828, -5294, -2720, 595};
    int sizeOf = sizeof(intArray) / sizeof(intArray[0]);
    selectionSortGreater(intArray, sizeOf);
    print(intArray, sizeOf);
    return 0;
}

def myAlgorithmDESC(arr, n):

    for i in range(1, n):

        currentVal = arr[i] 
        j = i - 1

        
        while j >= 0 and (arr[j] < currentVal):

            arr[j + 1] = arr[j]
            j = j - 1

        arr[j + 1] = currentVal


    for i in range(0, n):
        print(f"{arr[i]}", end=', ')

    print("\n Fin del ordenamiento")


def myAlgorithmASC(arr, n):

    for i in range(1, n):

        currentVal = arr[i] 
        j = i - 1

        
        while j >= 0 and (arr[j] > currentVal):

            arr[j + 1] = arr[j]
            j = j - 1

        arr[j + 1] = currentVal


    for i in range(0, n):
        print(f"{arr[i]}", end=', ')

    print("\n Fin del ordenamiento")


def run():
    i = 0
    arr = []
    while True:
        number = input("Escribe un numero, para terminar escribe salir ---> ")
        if number == 'salir':
            break
           
        else:
            number = int(number)
            arr.append(number)
            i = i + 1

    print("Los valores ingresados son:")
    print(arr)
    print(f"numero de elementos: {i}")
    print("Opciones:")
    print(" 1 - Ordenarlo de menor a mayor")
    print(" 2 - Ordenarlo de mayor a menor")
    print(" 3 - Salir")
    opcion = input("---> ")

    if opcion == '1':
        myAlgorithmASC(arr, i)
    elif opcion == '2':
        myAlgorithmDESC(arr, i)
    else:
        print("Bye bye!")






if __name__ == "__main__":
    run()

#include <stdio.h> 
#include <math.h> 
  
void insertionSort(int arr[], int n) 
{ 
   int currentVal,j;
   for (int i = 1; i < n; i++) 
   { 
       currentVal= arr[i]; 
       j = i-1;
  
       while (j >= 0 && arr[j] < currentVal) 
       { 
           arr[j+1] = arr[j]; 
           j = j-1; 
       } 
       arr[j+1] = currentVal; 
   } 
} 
  
void printArray(int arr[], int n) 
{ 
   int i; 
   for (i=0; i < n; i++) 
   {
   	   printf("%d , ", arr[i]); 
   	   printf("%n"); 
	}
    
} 
  

int main() 
{ 
    int arr[] = {-796,3229,-5164,-362,4408,8965,-6068,9329,-3034,-443,-6693,9497,2615,-5966,-9065,-1160,6148,5517,1123,-8887,5649,3302,-1176,-8542,-9166,8,-2906
				 ,8987,-2414,-7984,4410,8872,5241,-4556,59,-5562,-3877,7452,-4467,2076,4076,4297,-3847,-2055,4483,-1484,-2371,6199,-7261,-7032,6010,2325,-6625
				 ,-2601,3870,1822,-5665,9622,9883,-5794,-5218,2926,-3099,6399,-2570,3943,-2409,5114,9791,-4420,1065,3077,-1062,-8004,4397,1635,8578,-9226,9222
				 ,-1793,-2691,-5060,-4727,-4098,946,-6558,-4111,4575,-2685,-4729,-5277,1936,5106,-2089,824,9421,-1683,-2083,7891,-2099,1305,-9076,-3535,2565,
				 -2871,9448,7177,-8614,-9954,-362,1455,-8834,-9846,-8412,1175,-1981,-5991,7201,-1997,-5156,-1634,-9803,1032,9551,-6153,8502,3536,-2980,8681,
				 -9210,4408,8780,-916,-369,-8651,1246,-702,-5555,23,8208,2037,6941,9545,-5147,5063,-8358,2772,8553,9885,4624,-3576,9131,1229,-429,-479,-673
				 ,-7060,-4031,5650,6679,6796,5622,-6256,-238,-6096,3096,-1610,-2948,6291,-1666,5219,5850,7387,-3260,3672,-1766,-9941,8252,2649,7079,-8026
				 ,6356,676,-5065,-6338,3287,680,-3269,2770,6637,-8744,9162,-2204,-3066,-7228,8762,1505,4957,766,-9136,4632,-5022,-9999,5361,2732,7831,-501
				 ,-4650,7236,3682,-2438,5574,-8230,-9669,-7442,7966,-2905,7629,7137,200,-8670,-749,2228,458,7889,-3668,-5350,-3261,6741,-6953,4800,3372,6662
				 ,-1018,8523,3164,3577,9720,-6826,-1574,-7875,-2796,-1078,-4755,4926,3368,4302,9254,6,410,-4689,7878,2461,8233,-6688,5904,4735,-2940,8830
				 ,9976,-3674,4222,-1446,6187,-3181,-8882,5487,-6939,-7885,3786,-6234,-1062,-4553,-5709,8459,5008,3352,6586,537,-7610,3261,8246,-2105,5107,7957
				 ,-7886,-2925,-2541,-7449,9521,5073,-239,-8054,-4379,-8323,-6485,-4828,-5294,-2720,595}; 
				 
    int n = sizeof(arr)/sizeof(arr[0]); 
  
    insertionSort(arr, n); 
    printArray(arr, n); 
  
    return 0; 
}

using System;
using System.IO;
namespace InsertionSort
{
    class InsertionSort
    {
        public static void Main(string[] args)
        {
            InsertionSortImplemetation();
        }
                
       static void InsertionSortImplemetation()
       {

         string fileName = @"C:\Users\Dell\Wellington\Desktop\Programing\Algorithms\InsertionSort/numbers.txt";
         StreamReader reader;
         string[] dataToArrString;
         string data;
         int[] numbers;
         reader = new StreamReader(fileName, true);
             
             if(File.Exists(fileName))
             {
                    data = reader.ReadToEnd();
                    dataToArrString = data.Split(", ");
                    numbers = new int[dataToArrString.Length];

                    for (int i = 0; i < dataToArrString.Length; i++)
                    {
                        numbers[i] = int.Parse(dataToArrString[i]);
                         
                    }

                  for (int i = 0; i < numbers.Length; i++)
                  {
                      for (int j = i; j < numbers.Length-1; j++)
                      {
                             
                             if(numbers[i] < numbers[j+1])
                             {
                                 int temp = numbers[i];
                                 numbers[i] = numbers[j+1];
                                 numbers[j+1] = temp;
                                 
                             }
                      } 

                      
                  }
                  
             }else {
                Console.WriteLine("File does not exits");
                return;
             }
             
          
          foreach (var num in numbers)
          {
            Console.Write(num + ", ");
          }
       }
    }

      
}
$ dotnet run
9976, 9885, 9883, 9791, 9720, 9622, 9551, 9545, 9521, 9497, 9448, 9421, 9329, 9254, 9222, 9162, 9131, 8987, 8965, 8872, 8830, 8780, 8762, 8681, 8599, 8578, 8553, 8523, 8502, 8459, 8252, 8246, 8233, 8208, 7966, 7957, 7891, 7889, 7878, 7831, 7629, 7452, 7387, 7236, 7201, 7177, 
7137, 7079, 6941, 6796, 6741, 6679, 6662, 6637, 6586, 6410, 6399, 6356, 6291, 6199, 6187, 6148, 6010, 5904, 5850, 5650, 5649, 5622, 5574, 5517, 5487, 5361, 5241, 5219, 5114, 5107, 5106, 5073, 5063, 5008, 4957, 4926, 4800, 4735, 4632, 4624, 4575, 4483, 4410, 4408, 4408, 4397, 
4302, 4297, 4222, 4076, 3943, 3870, 3786, 3682, 3672, 3577, 3536, 3372, 3368, 3352, 3302, 3287, 3261, 3229, 3164, 3096, 3077, 2926, 2772, 2770, 2732, 2649, 2615, 2565, 2461, 2325, 2228, 2076, 2037, 1936, 1822, 1635, 1505, 1455, 1305, 1246, 1229, 1175, 1123, 1065, 1032, 946, 824, 766, 680, 676, 595, 537, 458, 200, 59, 23, 8, -238, -239, -362, -362, -369, -429, -443, 
-479, -501, -673, -702, -749, -796, -916, -1018, -1062, -1062, -1078, -1160, -1176, -1446, -1484, -1574, -1610, -1634, -1666, -1683, -1766, -1793, -1981, -1997, -2055, -2083, -2089, -2099, -2105, -2204, -2371, -2409, -2414, -2438, -2541, -2570, -2601, -2685, -2691, -2720, -2796, -2871, -2905, -2906, -2925, -2940, -2948, -2980, -3034, -3066, -3099, -3181, -3260, -3261, -3269, -3535, -3576, -3668, -3674, -3847, -3877, -4031, -4098, -4111, -4379, -4420, -4467, -4553, -4556, -4650, -4689, -4727, -4729, -4755, -4828, -5022, -5060, -5065, -5147, -5156, -5164, -5218, -5277, -5294, -5350, -5555, -5562, -5665, -5709, -5794, -5966, -5991, -6068, 
-6096, -6153, -6234, -6256, -6338, -6485, -6558, -6625, -6688, -6693, -6826, -6939, -6953, -7032, -7060, -7228, -7261, -7442, -7449, -7610, -7875, -7885, -7886, -7984, -8004, -8026, -8054, -8230, -8323, -8358, -8412, -8542, -8614, -8651, -8670, -8744, -8834, -8882, -8887, -9065, -9076, -9136, -9166, -9210, -9226, -9669, -9803, -9846, -9941, -9954, -9999

def bubbleSort(arr, n):
    for i in range(0, n-1):
        for j in range(0, n-i-1):
            if arr[j] < arr[j+1]:
                temp = arr[j]
                arr[j] = arr[j+1]
                arr[j+1] = temp
            
arr_sort = []

def arrSort(arr, n):
    for i in range(n):
        arr_sort.append(arr[i])

def main():
    lista = [-796, 3229, -5164, -362, 4408, 8965, -6068, 9329, -3034, -443,
		-6693, 9497, 2615, -5966, -9065, -1160, 6148, 5517, 1123, -8887,
		5649, 3302, -1176, -8542, -9166, 8, -2906, 8987, -2414, -7984,
		4410, 8872, 5241, -4556, 59, -5562, -3877, 7452, -4467, 2076,
		4076, 4297, -3847, -2055, 4483, -1484, -2371, 6199, -7261, -7032,
		6010, 2325, -6625, -2601, 3870, 1822, -5665, 9622, 9883, -5794,
		-5218, 2926, 8599, -3099, 6399, -2570, 3943, -2409, 5114, 9791,
		-4420, 1065, 3077, -1062, -8004, 4397, 1635, 8578, -9226, 9222,
		-1793, -2691, -5060, -4727, -4098, 946, -6558, -4111, 4575, -2685,
		-4729, -5277, 1936, 5106, -2089, 824, 9421, -1683, -2083, 7891,
		-2099, 1305, -9076, -3535, 2565, -2871, 9448, 7177, -8614, -9954,
		-362, 1455, -8834, -9846, -8412, 1175, -1981, -5991, 7201, -1997,
		-5156, -1634, -9803, 1032, 9551, -6153, 8502, 3536, -2980, 8681,
		-9210, 4408, 8780, -916, -369, -8651, 1246, -702, -5555, 23,
		8208, 2037, 6941, 9545, -5147, 5063, -8358, 2772, 8553, 9885,
		4624, -3576, 9131, 1229, -429, -479, -673, -7060, -4031, 5650,
		6679, 6796, 5622, -6256, -238, -6096, 3096, -1610, -2948, 6291,
		-1666, 5219, 5850, 7387, -3260, 3672, -1766, -9941, 8252, 2649,
		7079, -8026, 6356, 676, -5065, -6338, 3287, 680, -3269, 2770,
		6637, -8744, 9162, -2204, -3066, -7228, 8762, 1505, 4957, 766,
		-9136, 4632, -5022, -9999, 5361, 2732, 7831, -501, -4650, 7236,
		3682, -2438, 5574, -8230, -9669, -7442, 7966, -2905, 7629, 7137,
		200, -8670, -749, 2228, 458, 7889, -3668, -5350, -3261, 6741,
		-6953, 3372, 6662, -1018, 8523, 3164, 3577, 9720, -6826, -1574,
		-7875, -2796, -1078, -4755, 4926, 3368, 4302, 9254, 6410, -4689,
		7878, 2461, 8233, -6688, 5904, 4735, -2940, 8830, 9976, -3674,
		4222, -1446, 6187, -3181, -8882, 5487, -6939, -7885, 3786, -6234,
        -1062, -4553, -5709, 8459, 5008, 3352, 6586, 537, -7610, 3261, 8246, 
        -2105, 5107, 7957, -7886, -2925, -2541, -7449, 9521, 5073, -239, -8054, 
        -4379, -8323, -6485, -4828, -5294, -2720, 595, 9995]
    div = len(lista)
    bubbleSort(lista, div)
    arrSort(lista, div)
    print(f'Arreglo ordenado: {arr_sort}')

if __name__ == "__main__":
    main() 

import random


def quick_sort(lista):
    izquierda = []
    centro = []
    derecha = []
    if len(lista) > 1:
        pivote = lista[0]
        for i in lista:
            if i < pivote:
                izquierda.append(i)
            elif i == pivote:
                centro.append(i)
            elif i > pivote:
                derecha.append(i)
        # print(f'izq{izquierda} - cent{centro} - der{derecha}\n')
        return quick_sort(izquierda)+centro+quick_sort(derecha)
    else:
      return lista


def generar_lista_enteros(min,max,long):
    return[random.randint(min,max) for i in range(long)]


def main():
    num_riccelis = generar_lista_enteros(-1000000, 1000000,1000000)

    print(f'\nLista original:\n\n{num_riccelis}\n')
    lista_ordenada = quick_sort(num_riccelis)
    print(f'\nLista ordenada:\n\n{lista_ordenada}')
    print(f'\nLa lista contiene:\n\n{len(num_riccelis)} elementos')



if __name__ == '__main__':
    main()

import pandas as pd
import numpy as np
from tkinter import filedialog as FileDialog

def quicksort(L, first, last):
    # definimos los índices y calculamos el pivote
    i = first
    j = last 
    #Seleccionamos el mejor pivote
    pivote = (L[i] + L[j]) / 2
    
    # iteramos hasta que i no sea menor que j
    while i < j:
        # iteramos mientras que el valor de L[i] sea mayo que pivote
        while L[i] > pivote:
            # Incrementamos el índice
            i+=1
        # iteramos mientras que el valor de L[j] sea menor que pivote
        while L[j] < pivote:
            # decrementamos el índice
            j-=1
        # si i es menor o igual que j significa que los índices se han cruzado
        if i <= j:
            # creamos una variable temporal para guardar el valor de L[j]
            x = L[j]
            # intercambiamos los valores de L[j] y L[i]
            L[j] = L[i]
            L[i] = x
            # incrementamos y decrementamos i y j respectivamente
            i+=1
            j-=1

    # si first es menor que j mantenemos la recursividad
    if first < j:
        L = quicksort(L, first, j)
    # si last es mayor que i mantenemos la recursividad
    if last > i:
        L = quicksort(L, i, last)

    # devolvemos la lista ordenada
    return L

def getLista(hoja1):
    lista1 = hoja1.values.tolist()
    lista2 = []
    for i,v in enumerate(lista1):
        lista2.append(v[0])

    return lista2
ruta_excel = FileDialog.askopenfilename(
    title="Abrir el archivo",
    initialdir='.',
    filetypes=(("Ficheros de excel", "*.xlsx"),)
) 
hoja = pd.read_excel(ruta_excel,sheet_name="Hoja1")         #Se guarda la lista en el dataframe hoja
lista = getLista(hoja)
print("Lista Ordenada:",quicksort(lista,0,len(lista)-1))```

const bubbleSort = arr => {
    const l = arr.length;
    for (let i = 0; i < l; i++) {
        for (let j = 0; j < l - 1 - i; j++) {
            if (arr[j] < arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
    }
  return arr;
};

const arr = [-796, 3229, - 5164, - 362, 4408, 8965, - 6068, 9329, - 3034,
     - 443, - 6693, 9497, 2615, - 5966, - 9065, - 1160, 6148, 5517, 1123,
     - 8887, 5649, 3302, - 1176, - 8542, - 9166, 8, - 2906, 8987, - 2414, 
     - 7984, 4410, 8872, 5241, - 4556, 59, - 5562, - 3877, 7452, - 4467, 
      2076, 4076, 4297, - 3847, - 2055, 4483, - 1484, - 2371, 6199, - 7261,
     - 7032, 6010, 2325, - 6625, - 2601, 3870, 1822, - 5665, 9622, 9883, 
     - 5794, - 5218, 2926, 8599, - 3099, 6399, - 2570, 3943, - 2409, 5114, 
     9791, - 4420, 1065, 3077, - 1062, - 8004, 4397, 1635, 8578, - 9226, 9222, 
     - 1793, - 2691, - 5060, - 4727, - 4098, 946, - 6558, - 4111, 4575, - 2685, 
     - 4729, - 5277, 1936, 5106, - 2089, 824, 9421, - 1683, - 2083, 7891, - 2099, 
     130, - 9076, - 3535, 2565, - 2871, 9448, 7177, - 8614, - 9954, - 362, 1455, 
     - 8834, - 9846, - 8412, 1175, - 1981, - 5991, 7201, - 1997, - 5156, - 1634, 
     - 9803, 1032, 9551, - 6153, 8502, 3536, - 2980, 8681, - 9210, 4408, 8780,
     - 916, - 369, - 8651, 1246, - 702, - 5555, 23, 8208, 2037, 6941, 9545, 
     - 5147, 5063, - 8358, 2772, 8553, 9885, 4624, - 3576, 9131, 1229, - 429,
     - 479, - 673, - 7060, - 4031, 5650, 6679, 6796, 5622, - 6256, - 238, 
     - 6096, 3096, - 1610, - 2948, 6291, - 1666, 5219, 5850, 7387, - 3260, 
     3672, - 1766, - 9941, 8252, 2649, 7079, - 8026, 6356, 676, - 5065, 
     - 6338, 3287, 680, - 3269, 2770, 6637, - 8744, 9162, - 2204, - 3066, 
     - 7228, 8762, 1505, 4957, 766, - 9136, 4632, - 5022, - 9999, 5361, 2732,
     7831, - 501, - 4650, 7236, 3682, - 2438, 5574, - 8230,- 9669, - 7442, 7966,
     - 2905, 7629, 7137, 200, - 8670, - 749, 2228, 458, 7889, - 3668, - 5350, 
     - 3261, 6741, - 6953, 4800, 3372, 6662, - 1018, 8523, 3164, 3577, 9720, 
     - 6826, - 1574, - 7875, - 2796, - 1078, - 4755, 4926, 3368, 4302, 9254,
     6410, - 4689, 7878, 2461, 8233, - 6688, 5904, 4735, - 2940, 8830, 9976, 
     - 3674, 4222,- 1446, 6187- 3181, - 8882, 5487, - 6939, - 7885, 3786, 
     - 6234, - 1062, - 4553, - 5709, 8459, 5008, 3352, 6586, 537, - 7610, 
     3261, 8246, - 2105, 5107, 7957, - 7886, - 2925, - 2541, - 7449, 9521, 
     5073, - 239, - 8054, - 4379, - 8323, - 6485, - 4828, - 5294, - 2720, 595];

     const result = bubbleSort(arr);
     result;```

public class Orden {

    public void orden(int[]values){
        int aux=0;
        for (int i = 0; i <values.length ; i++) {
            for (int j=i+1; j<values.length; j++){
                if(values[i] > values[j]){
                    aux = values[j];
                    values[j] = values[i];
                    values[i] = aux;
                }
            }
        }
    }

    public void printValues(int []values){
        for (int i = 0; i < values.length ; i++) {
            System.out.println(values[i]);
        }

    }
}

********************************

public class Main {

    public static void main(String[] args) {
        int []values = {-796,3229,-5164 ,-362 ,4408 ,8965 ,-6068 ,9329 ,-3034 ,-443 ,-6693 ,9497 ,2615 ,-5966 ,-9065 ,-1160 ,6148 ,5517 ,1123 ,-8887 ,5649 ,3302 ,-1176 ,-8542 ,-9166 ,8 ,-2906 ,8987 ,-2414 ,-7984 ,4410 ,8872 ,5241 ,-4556 ,59 ,-5562 ,-3877 ,7452 ,-4467 ,2076 ,4076 ,4297 ,-3847 ,-2055 ,4483 ,-1484 ,-2371 ,6199 ,-7261 ,-7032 ,6010 ,2325 ,-6625 ,-2601 ,3870 ,1822 ,-5665 ,9622 ,9883 ,-5794 ,-5218 ,2926 ,8599 ,-3099 ,6399 ,-2570 ,3943 ,-2409 ,5114 ,9791 ,-4420 ,1065 ,3077 ,-1062 ,-8004 ,4397 ,1635 ,8578 ,-9226 ,9222 ,-1793 ,-2691 ,-5060 ,-4727 ,-4098 ,946 ,-6558 ,-4111 ,4575 ,-2685 ,-4729 ,-5277 ,1936 ,5106 ,-2089 ,824 ,9421 ,-1683 ,-2083 ,7891 ,-2099 ,1305 ,-9076 ,-3535 ,2565 ,-2871 ,9448 ,7177 ,-8614 ,-9954 ,-362 ,1455 ,-8834 ,-9846 ,-8412 ,1175 ,-1981 ,-5991 ,7201 ,-1997 ,-5156 ,-1634 ,-9803 ,1032 ,9551 ,-6153 ,8502 ,3536 ,-2980 ,8681 ,-9210 ,4408 ,8780 ,-916 ,-369 ,-8651 ,1246 ,-702 ,-5555 ,23 ,8208 ,2037 ,6941 ,9545 ,-5147 ,5063 ,-8358 ,2772 ,8553 ,9885 ,4624 ,-3576 ,9131 ,1229 ,-429 ,-479 ,-673 ,-7060 ,-4031 ,5650 ,6679 ,6796 ,5622 ,-6256 ,-238 ,-6096 ,3096 ,-1610 ,-2948 ,6291 ,-1666 ,5219 ,5850 ,7387 ,-3260 ,3672 ,-1766 ,-9941 ,8252 ,2649 ,7079 ,-8026 ,6356 ,676 ,-5065 ,-6338 ,3287 ,680 ,-3269 ,2770 ,6637 ,-8744 ,9162 ,-2204 ,-3066 ,-7228 ,8762 ,1505 ,4957 ,766 ,-9136 ,4632 ,-5022 ,-9999 ,5361 ,2732 ,7831 ,-501 ,-4650 ,7236 ,3682 ,-2438 ,5574 ,-8230 ,-9669 ,-7442 ,7966 ,-2905 ,7629 ,7137 ,200 ,-8670 ,-749 ,2228 ,458 ,7889 ,-3668 ,-5350 ,-3261 ,6741 ,-6953 ,4800 ,3372 ,6662 ,-1018 ,8523 ,3164 ,3577 ,9720 ,-6826 ,-1574 ,-7875 ,-2796 ,-1078 ,-4755 ,4926 ,3368 ,4302 ,9254 ,6410 ,-4689 ,7878 ,2461 ,8233 ,-6688 ,5904 ,4735 ,-2940 ,8830 ,9976 ,-3674 ,4222 ,-1446 ,6187 ,-3181 ,-8882 ,5487 ,-6939 ,-7885 ,3786 ,-6234 ,-1062 ,-4553 ,-5709 ,8459 ,5008 ,3352 ,6586 ,537 ,-7610 ,3261 ,8246 ,-2105 ,5107 ,7957 ,-7886 ,-2925 ,-2541 ,-7449-796,3229,-5164,-362 ,4408 ,8965 ,-6068 ,9329 ,-3034 ,-443 ,-6693 ,9497 ,2615 ,-5966 ,-9065 ,-1160 ,6148 ,5517 ,1123 ,-8887 ,5649 ,3302 ,-1176 ,-8542 ,-9166 ,8 ,-2906 ,8987 ,-2414 ,-7984 ,4410 ,8872 ,5241 ,-4556 ,59 ,-5562 ,-3877 ,7452 ,-4467 ,2076 ,4076 ,4297 ,-3847 ,-2055 ,4483 ,-1484 ,-2371 ,6199 ,-7261 ,-7032 ,6010 ,2325 ,-6625 ,-2601 ,3870 ,1822 ,-5665 ,9622 ,9883 ,-5794 ,-5218 ,2926 ,8599 ,-3099 ,6399 ,-2570 ,3943 ,-2409 ,5114 ,9791 ,-4420 ,1065 ,3077 ,-1062 ,-8004 ,4397 ,1635 ,8578 ,-9226 ,9222 ,-1793 ,-2691 ,-5060 ,-4727 ,-4098 ,946 ,-6558 ,-4111 ,4575 ,-2685 ,-4729 ,-5277 ,1936 ,5106 ,-2089 ,824 ,9421 ,-1683 ,-2083 ,7891 ,-2099 ,1305 ,-9076 ,-3535 ,2565 ,-2871 ,9448 ,7177 ,-8614 ,-9954 ,-362 ,1455 ,-8834 ,-9846 ,-8412 ,1175 ,-1981 ,-5991 ,7201 ,-1997 ,-5156 ,-1634 ,-9803 ,1032 ,9551 ,-6153 ,8502 ,3536 ,-2980 ,8681 ,-9210 ,4408 ,8780 ,-916 ,-369 ,-8651 ,1246 ,-702 ,-5555 ,23 ,8208 ,2037 ,6941 ,9545 ,-5147 ,5063 ,-8358 ,2772 ,8553 ,9885 ,4624 ,-3576 ,9131 ,1229 ,-429 ,-479 ,-673 ,-7060 ,-4031 ,5650 ,6679 ,6796 ,5622 ,-6256 ,-238 ,-6096 ,3096 ,-1610 ,-2948 ,6291 ,-1666 ,5219 ,5850 ,7387 ,-3260 ,3672 ,-1766 ,-9941 ,8252 ,2649 ,7079 ,-8026 ,6356 ,676 ,-5065 ,-6338 ,3287 ,680 ,-3269 ,2770 ,6637 ,-8744 ,9162 ,-2204 ,-3066 ,-7228 ,8762 ,1505 ,4957 ,766 ,-9136 ,4632 ,-5022 ,-9999 ,5361 ,2732 ,7831 ,-501 ,-4650 ,7236 ,3682 ,-2438 ,5574 ,-8230 ,-9669 ,-7442 ,7966 ,-2905 ,7629 ,7137 ,200 ,-8670 ,-749 ,2228 ,458 ,7889 ,-3668 ,-5350 ,-3261 ,6741 ,-6953 ,4800 ,3372 ,6662 ,-1018 ,8523 ,3164 ,3577 ,9720 ,-6826 ,-1574 ,-7875 ,-2796 ,-1078 ,-4755 ,4926 ,3368 ,4302 ,9254 ,6410 ,-4689 ,7878 ,2461 ,8233 ,-6688 ,5904 ,4735 ,-2940 ,8830 ,9976 ,-3674 ,4222 ,-1446 ,6187 ,-3181 ,-8882 ,5487 ,-6939 ,-7885 ,3786 ,-6234 ,-1062 ,-4553 ,-5709 ,8459 ,5008 ,3352 ,6586 ,537 ,-7610 ,3261 ,8246 ,-2105 ,5107 ,7957 ,-7886 ,-2925 ,-2541 ,-7449 ,9521 ,5073 ,-239 ,-8054 ,-4379 ,-8323 ,-6485 ,-4828 ,-5294 ,-2720 ,595 };

        Orden orden1 = new Orden();
        orden1.orden(values);
        System.out.println("elementos ordenandos");
        orden1.printValues(values);
    }
}

import timeit
from random import randint

def bubble_sort(arr):
	for i in range(len(arr)):
		for j in range(0, len(arr) - i - 1):
			if arr[j] > arr[j + 1]:
				arr[j], arr[j + 1] = arr[j + 1], arr[j]

def insertion_sort(arr):
	for i in range(1, len(arr)):
		currentVal = arr[i]
		j = i - 1
		while j >= 0 and arr[j] > currentVal:
			arr[j + 1] = arr[j]
			j -= 1
		arr[j + 1] = currentVal

def make_random_array():
	return [randint(-100, 100) for i in range(20)]

test_array1 = make_random_array()
test_array2 = make_random_array()
test_array3 = make_random_array()


def compare_functions():

	setup_code1 = """
from __main__ import bubble_sort
from __main__ import test_array1
	""" 

	setup_code2 = """
from __main__ import insertion_sort
from __main__ import test_array2
	"""

	setup_code3 = """
from __main__ import test_array3
	"""

	code1 = "bubble_sort(test_array1)"
	code2 = "insertion_sort(test_array2)"
	code3 = "sorted(test_array3)"

	time1 = timeit.repeat(stmt=code1, setup=setup_code1, number=1000, repeat=5)
	time2 = timeit.repeat(stmt=code2, setup=setup_code2, number=1000, repeat=5)
	time3 = timeit.repeat(stmt=code3, setup=setup_code3, number=1000, repeat=5)

	print(f"Tiempo para terminar bubble sort es {min(time1)} segundos.")
	print(f"Tiempo para terminar insertion sort es {min(time2)} segundos.")
	print(f"Tiempo para terminar sorted es {min(time3)} segundos.")

def run_sorts():
	test_array1 = make_random_array()
	test_array2 = make_random_array()
	test_array3 = make_random_array()
	print(f"Vector antes de bubble sort: {test_array1}")
	bubble_sort(test_array1)
	print(f"Vector después de bubble sort: {test_array1}")
	print("-"*50)
	print(f"Vector antes de insertion sort: {test_array2}")
	insertion_sort(test_array2)
	print(f"Vector después de insertion sort: {test_array2}")
	print("-"*50)
	print(f"Vector antes de sorted: {test_array3}")
	print(f"Vector después de sorted: {sorted(test_array3)}")

if __name__ == "__main__":
	compare_functions()
	run_sorts()

#ifndef NUMBERSET_H
#define NUMBERSET_H
#define ITEMS 300
#include <fstream>
#include <iostream>

class DataSet{
    private:
        void loadSet();
    public:
        DataSet();
        void print();
        int getN();
        int numberSet[ITEMS];
    
};

DataSet::DataSet(){
    loadSet();
}

void DataSet::loadSet(){
    std::string line;
    std::ifstream file("dataSet.txt");

    if(file.is_open()){
        int i = 0;
        while(getline(file, line)){
            numberSet[i] = std::stoi(line);
            i++;
        }
    }
}

void DataSet::print(){
    for(int i = 0; i < ITEMS; i++)
        std::cout << numberSet[i] << " ";
}

int DataSet::getN(){
    return ITEMS;
}

#endif ```

const insertionSort = (arr) => {
    let n = arr.length;
        for (let i = 1; i < n; i++) {
            let a = arr[i];
            let j = i-1; 
            while ((j > -1) && (a < arr[j])) {
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = a;
        }
    return arr;
}

console.log(insertionSort([-796, 3229, -5164, -362, 4408, 8965, -6068, 9329, -3034,
    -443, -6693, 9497, 2615, -5966, -9065, -1160, 6148, 5517, 1123,
    -8887, 5649, 3302, -1176, -8542, -9166, 8, -2906, 8987, -2414,
    -7984, 4410, 8872, 5241, -4556, 59, -5562, -3877, 7452, -4467,
    2076, 4076, 4297, -3847, -2055, 4483, -1484, -2371, 6199, -7261,
    -7032, 6010, 2325, -6625, -2601, 3870, 1822, -5665, 9622, 9883,
    -5794, -5218, 2926, 8599, -3099, 6399, -2570, 3943, -2409, 5114,
    9791, -4420, 1065, 3077, -1062, -8004, 4397, 1635, 8578, -9226,
    9222, -1793, -2691, -5060, -4727, -4098, 946, -6558, -4111, 4575,
    -2685, -4729, -5277, 1936, 5106, -2089, 824, 9421, -1683, -2083,
    7891, -2099, 1305, -9076, -3535, 2565, -2871, 9448, 7177, -8614,
    -9954, -362, 1455, -8834, -9846, -8412, 1175, -1981, -5991, 7201,
    -1997, -5156, -1634, -9803, 1032, 9551, -6153, 8502, 3536, -2980,
    8681, -9210, 4408, 8780, -916, -369, -8651, 1246, -702, -5555,
    23, 8208, 2037, 6941, 9545, -5147, 5063, -8358, 2772, 8553, 9885,
    4624, -3576, 9131, 1229, -429, -479, -673, -7060, -4031, 5650,
    6679, 6796, 5622, -6256, -238, -6096, 3096, -1610, -2948, 6291,
    -1666, 5219, 5850, 7387, -3260, 3672, -1766, -9941, 8252, 2649,
    7079, -8026, 6356, 676, -5065, -6338, 3287, 680, -3269, 2770,
    6637, -8744, 9162, -2204, -3066, -7228, 8762, 1505, 4957, 766,
    -9136, 4632, -5022, -9999, 5361, 2732, 7831, -501, -4650, 7236, 
    3682, -2438, 5574, -8230, -9669, -7442, 7966, -2905, 7629, 7137, 
    200, -8670, -749, 2228, 458, 7889, -3668, -5350, -3261, 6741, 
    -6953, 4800, 3372, 6662, -1018, 8523, 3164, 3577, 9720, -6826, 
    -1574, -7875, -2796, -1078, -4755, 4926, 3368, 4302, 9254, 6410,
    -4689, 7878, 2461, 8233, -6688, 5904, 4735, -2940, 8830, 9976, 
    -3674, 4222, -1446, 6187, -3181, -8882, 5487, -6939, -7885, 3786,
    -6234, -1062, -4553, -5709, 8459, 5008, 3352, 6586, 537, -7610, 
    3261, 8246, -2105, 5107, 7957, -7886, -2925, -2541, -7449, 9521, 
    5073, -239, -8054, -4379, -8323, -6485, -4828, -5294, -2720, 595]))

#include <stdio.h>



void cambio(int *n1, int *n2)
{
    int aux = *n1;
    *n1 = *n2;
    *n2 = aux;
}

int main(int argc, char const *argv[])
{
    int array[]={-796, 3229,
-5164,
-362,
4408,
8965,
-6068,
9329,
-3034,
-443,
-6693,
9497,
2615,
-5966,
-9065,
-1160,
6148,
5517,
1123,
-8887,
5649,
3302,
-1176,
-8542,
-9166,
8,
-2906,
8987,
-2414,
-7984,
4410,
8872,
5241,
-4556,
59,
-5562,
-3877,
7452,
-4467,
2076,
4076,
4297,
-3847,
-2055,
4483,
-1484,
-2371,
6199,
-7261,
-7032,
6010,
2325,
-6625,
-2601,
3870,
1822,
-5665,
9622,
9883,
-5794,
-5218,
2926,
8599,
-3099,
6399,
-2570,
3943,
-2409,
5114,
9791,
-4420,
1065,
3077,
-1062,
-8004,
4397,
1635,
8578,
-9226,
9222,
-1793,
-2691,
-5060,
-4727,
-4098,
946,
-6558,
-4111,
4575,
-2685,
-4729,
-5277,
1936,
5106,
-2089,
824,
9421,
-1683,
-2083,
7891,
-2099,
1305,
-9076,
-3535,
2565,
-2871,
9448,
7177,
-8614,
-9954,
-362,
1455,
-8834,
-9846,
-8412,
1175,
-1981,
-5991,
7201,
-1997,
-5156,
-1634,
-9803,
1032,
9551,
-6153,
8502,
3536,
-2980,
8681,
-9210,
4408,
8780,
-916,
-369,
-8651,
1246,
-702,
-5555,
23,
8208,
2037,
6941,
9545,
-5147,
5063,
-8358,
2772,
8553,
9885,
4624,
-3576,
9131,
1229,
-429,
-479,
-673,
-7060,
-4031,
5650,
6679,
6796,
5622,
-6256,
-238,
-6096,
3096,
-1610,
-2948,
6291,
-1666,
5219,
5850,
7387,
-3260,
3672,
-1766,
-9941,
8252,
2649,
7079,
-8026,
6356,
676,
-5065,
-6338,
3287,
680,
-3269,
2770,
6637,
-8744,
9162,
-2204,
-3066,
-7228,
8762,
1505,
4957,
766,
-9136,
4632,
-5022,
-9999,
5361,
2732,
7831,
-501,
-4650,
7236,
3682,
-2438,
5574,
-8230,
-9669,
-7442,
7966,
-2905,
7629,
7137,
200,
-8670,
-749,
2228,
458,
7889,
-3668,
-5350,
-3261,
6741,
-6953,
4800,
3372,
6662,
-1018,
8523,
3164,
3577,
9720,
-6826,
-1574,
-7875,
-2796,
-1078,
-4755,
4926,
3368,
4302,
9254,
6410,
-4689,
7878,
2461,
8233,
-6688,
5904,
4735,
-2940,
8830,
9976,
-3674,
4222,
-1446,
6187,
-3181,
-8882,
5487,
-6939,
-7885,
3786,
-6234,
-1062,
-4553,
-5709,
8459,
5008,
3352,
6586,
537,
-7610,
3261,
8246,
-2105,
5107,
7957,
-7886,
-2925,
-2541,
-7449,
9521,
5073,
-239,
-8054,
-4379,
-8323,
-6485,
-4828,
-5294,
-2720,
595};
    int i, j;
    int n = sizeof(array) / sizeof(array[0]);
    for(i = 0; i < n; i++)
    {
        for(j = i; j < n; j++)
        {

            if(array[i]>array[j])
            {
            cambio(&array[i], &array[j]);
            }
        }
        printf("%i, ", array[i]);
    }
printf("\n");



    return 0;
}

<var numbersToOrder = document.getElementById("numbersToOrder");
var order = document.getElementById("order");
var result =  document.getElementById("result");

order.addEventListener("click", function() { 

    var numeros = [];
    var inputString = numbersToOrder.value;
    numeros = inputString.split(",");
    parseIntArray(numeros);
    insertionSort(numeros);
    result.innerHTML = numeros ;

});

function parseIntArray(inputArr) {
    let n = inputArr.length;
        for (let i = 1; i < n; i++) {
            inputArr[i] = parseInt(inputArr[i]);
        }
    return inputArr;
}

function insertionSort(inputArr) {
    let n = inputArr.length;
        for (let i = 1; i < n; i++) {
            // Choosing the first element in our unsorted subarray
            let current = inputArr[i];
            // The last element of our sorted subarray
            let j = i-1; 
            while ((j > -1) && (current < inputArr[j])) {
                inputArr[j+1] = inputArr[j];
                j--;
            }
            inputArr[j+1] = current;
        }
    return inputArr;
}>

<<!DOCTYPE html>
<html lang="es">
<head>
<title>Titulo de la web| Menos de 55 caracteres</title>
<meta charset="utf-8" />
<meta name="description" content="Debe contener las palabras clave, tratar de atraer clicks y de longitud entre 150 y 160 caracteres">

</head>
 
<body>
   
    <header>
       <h2>Mi sitio web</h2>
       <p>Mi sitio web creado en html5</p>
       
    </header>
    <section>
        <p><label>ingrese los numeros a ordenar separados por coma:</label></p>

        <p><input type="text" id="numbersToOrder" name="name" size="30"></p>
        
        <p><button id="order" type="button">Order</button></p>
        
        <p><label id="result"></label></p>

    </section>

</body>
<script type="text/javascript" src="algoritmo.js"></script>
</html>>

#include <stdio.h>
#include <stdlib.h>
#define MAX 301

void cambiarPor(int *n1,int *n2);
void bubblesort(int vector_entrada[],int n);
int print(int vector_entrada[],int n);

int main(int argc, char const *argv[]) {


  FILE * fp = fopen( "numeros.txt", "r");

  char buf[MAX];
  int i = 0,numerosEnteros[MAX];

  while(i<300)
  {
  fgets(buf, MAX,fp );
  printf("numero is [ %d]: %s\n",i+1, buf);
  numerosEnteros[i] = atoi(buf);
  i++;
  }
  fclose(fp);

  int tamaño = sizeof(numerosEnteros)/sizeof(int);
  bubblesort(numerosEnteros,tamaño);
  print(numerosEnteros,tamaño);
  printf("\n");
  return 0;
}

void cambiarPor(int *n1,int *n2)
{
  int temp = *n1;
  *n1 = *n2;
  *n2 = temp;
}
void bubblesort(int vector_entrada[],int n)
{
  int i ,j;
  for( i = 0; i < n-1 ; i++)
  {
    for(j = 0; j < n-i-1 ; j++)
    {
      if(vector_entrada[j] < vector_entrada[j+1])
      {
          cambiarPor(&vector_entrada[j], &vector_entrada[j+1]);
      }
    }
  }
}

int print(int vector_entrada[],int n)
{
  int i;
  for( i = 0; i < n-1; i++)
  {
    printf("%d,", vector_entrada[i]);
  }
  printf("Fin del ordenamiento\n");
}

Wandy Rafael Santana Evangelista

student•

AQUÍ ESTAN LOS DATOS CON COMA PARA LOS QUE LO NECESITEN: -796, 3229, -5164, -362, 4408, 8965, -6068, 9329, -3034, -443, -6693, 9497, 2615, -5966, -9065, -1160, 6148, 5517, 1123, -8887 ,5649, 3302, -1176, -8542, -9166, 8, -2906, 8987, -2414, -7984, 4410, 8872, 5241, -4556, 59, -5562, -3877, 7452, -4467, 2076, 4076, 4297 ,-3847, -2055, 4483, -1484, -2371, 6199, -7261, -7032, 6010, 2325, -6625, -2601, 3870, 1822, -5665, 9622, 9883, -5794, -5218, 2926, 8599, -3099 ,6399, -2570, 3943, -2409, 5114, 9791, -4420, 1065, 3077, -1062, -8004, 4397, 1635, 8578, -9226, 9222, -1793, -2691, -5060, -4727, -4098 ,946, -6558, -4111, 4575, -2685, -4729, -5277, 1936, 5106, -2089, 824, 9421, -1683, -2083, 7891, -2099, 1305, -9076, -3535, 2565, -2871, 9448 ,7177, -8614, -9954, -362, 1455, -8834, -9846, -8412, 1175, -1981, -5991, 7201, -1997, -515, -1634, -9803, 1032, 9551, -6153, 8502, 3536 ,-2980, 8681, -9210, 4408, 8780, -916, -369, -8651, 1246, -702, -5555, 23, 8208, 2037, 6941, 9545, -5147, 5063, -8358, 2772, 8553, 9885, 4624 ,-3576, 9131, 1229, -429, -479, -673, -7060, -4031, 5650, 6679, 6796, 5622, -6256, -238, -6096, 3096, -1610, -2948, 6291, -1666, 5219, 5850, 7387 ,-3260, 3672, -1766, -9941, 8252, 2649, 7079, -8026, 6356, 676, -5065, -6338, 3287, 680, -3269, 2770, 6637, -8744, 9162, -2204, -3066, -7228, 8762 ,1505, 4957, 766, -9136, 4632, -5022, -9999, 5361, 2732, 7831, -501, -4650, 7236, 3682, -2438, 5574, -8230, -9669, -7442, 7966, -2905, 7629 ,7137, 200, -8670, -749, 2228, 458, 7889, -3668, -5350, -3261, 6741, -6953, 4800, 3372, 6662, -1018, 8523, 3164, 3577, 9720, -6826, -1574, -7875 ,-2796, -1078, -4755, 4926, 3368, 4302, 9254, 6410, -4689, 7878, 2461, 8233, -6688, 5904, 4735, -2940, 8830, 9976, -3674, 4222, -1446, 6187, -3181 ,-8882, 5487, -6939, -7885, 3786, -6234, -1062, -4553, -5709, 8459, 5008, 3352, 6586, 537, -7610, 3261, 8246, -2105, 5107, 7957, -7886, -2925, -2541 ,-7449, 9521, 5073, -239, -8054, -4379, -8323, -6485, -4828, -5294, -2720, 595

Manuel Valenzuela

rifaste, yo los estaba ordenando de uno en uno...

Yusei Umehara

Danelia Sanchez Sanchez

Aquí dejó la implementación del algoritmo de SelectionSort (Ordenamiento de Selección), es muy similar al BubbleSort. Los números están guardados en un archivo numbers.dat.

Si quieres ejecutarlo: https://repl.it/@DaneliaSanchez/selectionSort

Pablo Benedix

Hola!, muchísimas gracias por tu código, la verdad es que no encontraba la forma de como poner todos los números dentro del Array pero me salvaste con eso del FILE. Me voy a asegurar de mencionarte al subir mi código.

Miguel Ángel Baquero Tello

Hola. Muy buen aporte y muy buena idea al tomar los datos de un archivo externo.

Rubén Fabián Ponce Segura

Dejo una imagen gif de los algoritmos de ordenamiento para que agarren el que les parezca más interesante

Eduardo Monzón

Muy valioso, gracias

Carlos Isaac Rosales Castellanos

Hola a todos, realicé el desafío utilizando el algoritmo de ordenamiento llamado Selection Sort. Utilicé el material que dejó el compañero @eagskunst en otro comentario de este desafio, el material es este.

Hay dos funciones de ordenamiento en el código:

selectionSortMinor ordena de menor a mayor.

selectionSortGreater ordena de mayor a menor.

Utilicé la segunda por las especificaciones del desafío. Aquí está el código y el resultado:

output:

Ricardo Celis

teacher•

Excelente trabajo! Muchas gracias por compartir tu codigo tan detallado

Gean Carlo Reyes Alayo

RETO CUMPLIDO con python: NOTA: Me emocione y lo hice un poco interactivo jajaj

Luis Nilson Palma Campos

Reto cumplido ordenado de mayor a menor

Wellington Gabriel Muñoz Vargas

Nicolas Moina

Bubble Sort con python

Sergio Arturo Enriquez Nava

RETO: La verdad no me dieron muchas ganas de escribir tantos números y escribí una función para generar números aleatorios. La función para generar una lista de números aleatorios recibe tres parámetros(numero mínimo, numero máximo, longitud de la lista(arreglo))

NOTA: Si lo utilizas considera la longitud en la función <generar_lista_enteros> , si quieres ver el proceso de como funciona el quick sort descomenta el print dentro de la funcion quick_sort

Aqui aprendi como funciona el algoritmo Quick sort

Jaime Andres Serrano

Reto en Python con QuickSort: Pase la lista de números a un Excel, por medio de la librería cargue el Excel, luego convertir el dataframe en una lista normal:

Hector Alejandro Ramirez Huertas

Hey! Excelente trabajo e implementacion alejo!

Juliana Gonzalez

-9999 -9954 -9941 -9846 -9803 -9669 -9226 -9210 -9166 -9136 -9076 -9065 -8887 -8882 -8834 -8744 -8670 -8651 -8614 -8542 -8412 -8358 -8323 -8230 -8054 -8026 -8004 -7984 -7886 -7885 -7875 -7610 -7449 -7442 -7261 -7228 -7060 -7032 -6953 -6939 -6826 -6693 -6688 -6625 -6558 -6485 -6338 -6256 -6234 -6153 -6096 -6068 -5991 -5966 -5794 -5709 -5665 -5562 -5555 -5350 -5294 -5277 -5218 -5164 -5156 -5147 -5065 -5060 -5022 -4828 -4755 -4729 -4727 -4689 -4650 -4556 -4553 -4467 -4420 -4379 -4111 -4098 -4031 -3877 -3847 -3674 -3668 -3576 -3535 -3269 -3261 -3260 -3181 -3099 -3066 -3034 -2980 -2948 -2940 -2925 -2906 -2905 -2871 -2796 -2720 -2691 -2685 -2601 -2570 -2541 -2438 -2414 -2409 -2371 -2204 -2105 -2099 -2089 -2083 -2055 -1997 -1981 -1793 -1766 -1683 -1666 -1634 -1610 -1574 -1484 -1446 -1176 -1160 -1078 -1062 -1062 -1018 -916 -796 -749 -702 -673 -501 -479 -443 -429 -369 -362 -362 -239 -238 8 23 59 200 458 537 595 676 680 766 824 946 1032 1065 1123 1175 1229 1246 1305 1455 1505 1635 1822 1936 2037 2076 2228 2325 2461 2565 2615 2649 2732 2770 2772 2926 3077 3096 3164 3229 3261 3287 3302 3352 3368 3372 3536 3577 3672 3682 3786 3870 3943 4076 4222 4297 4302 4397 4408 4408 4410 4483 4575 4624 4632 4735 4800 4926 4957 5008 5063 5073 5106 5107 5114 5219 5241 5361 5487 5517 5574 5622 5649 5650 5850 5904 6010 6148 6187 6199 6291 6356 6399 6410 6586 6637 6662 6679 6741 6796 6941 7079 7137 7177 7201 7236 7387 7452 7629 7831 7878 7889 7891 7957 7966 8208 8233 8246 8252 8459 8502 8523 8553 8578 8599 8681 8762 8780 8830 8872 8965 8987 9131 9162 9222 9254 9329 9421 9448 9497 9521 9545 9551 9622 9720 9791 9883 9885 9976

Jesus Alexis Garcia Perez

javascript

function swap(myArr, indexOne, indexTwo){ if( indexOne == indexTwo ){ return myArr; } var tmpVal = myArr[indexOne]; myArr[indexOne] = myArr[indexTwo]; myArr[indexTwo] = tmpVal; return myArr; }

var myArr = [-796, 3229, -5164, -362, 4408, 8965, -6068, 9329, -3034, -443, -6693, 9497, 2615, -5966, -9065, -1160, 6148, 5517, 1123, -8887, 5649, 3302, -1176, -8542, -9166, 8, -2906, 8987, -2414, -7984, 4410, 8872, 5241, -4556, 59, -5562, -3877, 7452, -4467, 2076, 4076, 4297, -3847, -2055, 4483, -1484, -2371, 6199, -7261, -7032, 6010, 2325, -6625, -2601, 3870, 1822, -5665, 9622, 9883, -5794, -5218, 2926, 8599, -3099, 6399, -2570, 3943, -2409, 5114, 9791, -4420, 1065, 3077, -1062, -8004, 4397, 1635, 8578, -9226, 9222, -1793, -2691, -5060, -4727, -4098, 946, -6558, -4111, 4575, -2685, -4729, -5277, 1936, 5106, -2089, 824, 9421, -1683, -2083, 7891, -2099, 130, -9076, -3535, 2565, -2871, 9448, 7177, -8614, -9954, -362, 1455, -8834, -9846, -8412, 1175, -1981, -5991, 7201, -1997, -5156, -1634, -9803, 1032, 9551, -6153, 8502, 3536, -2980, 8681, -9210, 4408, 8780, -916, -369, -8651, 1246, -702, -5555, 23, 8208, 2037, 6941, 9545, -5147, 5063, -8358, 2772, 8553, 9885, 4624, -3576, 9131, 1229, -429, -479, -673, -7060, -4031, 5650, 6679, 6796, 5622, -6256, -238, -6096, 3096, -1610, -2948, 6291, -1666, 5219, 5850, 7387, -3260, 3672, -1766, -9941, 8252, 2649, 7079, -8026, 6356, 676, -5065, -6338, 3287, 680, -3269, 2770, 6637, -8744, 9162, -2204, -3066, -7228, 8762, 1505, 4957, 766, -9136, 4632, -5022, -9999, 5361, 2732, 7831, -501, -4650, 7236, 3682, -2438, 5574, -8230, -9669, -7442, 7966, -2905, 7629, 7137, 200, -8670, -749, 2228, 458, 7889, -3668, -5350, -3261, 6741, -6953, 4800, 3372, 6662, -1018, 8523, 3164, 3577, 9720, -6826, -1574, -7875, -2796, -1078, -4755, 4926, 3368, 4302, 9254, 6410, -4689, 7878, 2461, 8233, -6688, 5904, 4735, -2940, 8830, 9976, -3674, 4222, -1446, 6187 - 3181, -8882, 5487, -6939, -7885, 3786, -6234, -1062, -4553, -5709, 8459, 5008, 3352, 6586, 537, -7610, 3261, 8246, -2105, 5107, 7957, -7886, -2925, -2541, -7449, 9521, 5073, -239, -8054, -4379, -8323, -6485, -4828, -5294, -2720, 595]; console.log(selectionSort(myArr));

Laura Sofía Córdoba

Carlos Josue Razo Ochoa

Script en python corriendo tres tipos de algoritmos y comparando su tiempo de ejecución. Lo siento Celis, me dio flojera tomar tu array.

José María Caamaño González

Angel Solis

Creé una clase que carga en un array todo el set de datos que nos dió el profesor Ricardo. También tiene un método para imprimirlo y otro que devuelve la longitud de este. Así se podría evitar ingresar los datos en un array manualmente.

Marco Ezequiel Morales

Mi reto utilizando Insertion Sort en JS

Carlos Martin Castillo Jimenez

Juan Salinas

hice un insertion sort en js:

![](/home/juan/Imágenes/Captura de pantalla -2020-12-06 01-27-36.png)

js:

html:

Sergio Brandon De Lucio Chavero

Hice un código que permite ingresar un archivo de texto y así ordenar los números que contenga, da mucha flojera ingresar el arreglo completo :"v, les dejo el código, solo tienen que tener un archivo txt y listo :) <3

Algoritmos de Ordenamiento Descendente: Implementación Práctica

Bienvenido al Curso

Algoritmos y Estructuras de Datos: Curso Básico

Introducción a los algoritmos

Cómo Funcionan las Computadoras y el Sistema Binario

Introducción a Lenguajes de Programación: Bajo y Alto Nivel

Estructuras de Datos para Rutas Más Cortas en Mapas

Algoritmo de Dijkstra para encontrar la ruta más corta

Metodología para Resolver Algoritmos Paso a Paso

Variables y Tipos de Datos en Programación

Creación de Tipos de Datos Personalizados en C

Configuración de Ubuntu en Windows 10 para C/C++

Implementación de User Defined Data Type en C: Estructuras paso a paso

Tipos de Datos Abstractos y Estructuras de Datos en Programación

Tipos Abstractos de Datos: Lista, Pila, Cola y Diccionario

Tipos Abstractos de Datos: Listas, Pilas y Colas

Clases y objetos

Colas y estructuras de datos: gestión de pedidos en restaurante

Implementación de Queues con Arrays en Visual Studio Code

Implementación de Abstract Data Type en C: Función enqueue

Implementación de la función dequeue en estructuras de datos en C

Implementación de Colas en C: Declaración y Uso de Funciones Básicas

Algoritmos de ordenamiento

Algoritmos de Ordenamiento: Conceptos y Aplicaciones Básicas

Funcionamiento del Algoritmo de Ordenamiento Burbuja

Implementación de Bubble Sort en C paso a paso

Implementación de Bubble Sort en C y función de impresión

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

Algoritmos de Ordenamiento Descendente: Implementación Práctica

Recursividad

Recursividad en Programación: Entendiendo el Factorial

Factorial Recursivo en C: Implementación y Ejemplo

Inversión de cadenas con recursividad en Java

Recursividad en Python: Arte con Turtle y Funciones Recursivas

Divide and conquer y programación dinámica

Diseño y análisis de algoritmos: Divide y vencerás

Introducción a Programación Dinámica y Quicksort

Ordenamiento de Arrays con MergeSort en C

Algoritmos de Ordenamiento de Datos de Mayor a Menor

Algoritmo Quicksort en Python: Implementación y Funcionamiento

Ordenamiento Quick Sort en Python paso a paso

Algoritmos 'Greedy'

Algoritmos Voraces: Principios y Aplicaciones Prácticas

Implementación de Algoritmo Greedy para Cambio de Monedas

Cambio de Monedas en C++: Implementación y Ejecución

Grafos y árboles

Introducción a Árboles y Grafos: Estructuras de Datos Básicas

Estructura de Datos: Árboles y sus Componentes Básicos

¿Cómo comparar Algoritmos?

Comparación de Algoritmos: Complejidad y Ritmo de Crecimiento

¿Qué sigue?

Resolución de Problemas Básicos con Algoritmos y Estructuras de Datos