Desafío: implementa un algoritmo de ordenamiento

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

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.

#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;
}

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

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

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:

#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;
}

output:

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

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()

Reto cumplido ordenado de mayor a menor

#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; 
}

Bubble Sort con python

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() 

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

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()

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

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:

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))```

-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

javascript

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;```

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

function selectionSort(myArr) {
var size = myArr.length;
for (var slot = 0; slot < size -1; slot++) { // outer loop
var smallest = slot;
for (var check = slot + 1; check < size; check++) { // inner loop
if (myArr[check] > myArr[smallest]) {
smallest = check;
}
}
swap( myArr, smallest, slot );
}
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));

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

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

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()

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.

#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 ```

Mi reto utilizando Insertion Sort en JS

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;
}

hice un insertion sort en js:


js:

<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;
}>

html:

<<!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>
       <h1>Mi sitio web</h1>
       <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>>

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 😃 ❤️

#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");
}

Aquí tengo una solución sencilla usando Javascript

Reto completado:

#include<stdio.h>
void cambiar_pos(int *n1, int *n2){
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
void bubbleSort(int array[], int n){
    int i;
    int j;
    for(i = 0; i < n-1; i++){
        for(j = 0; j < n-i-1; j++){
            if(array[j]>array[j+1]){
                cambiar_pos(&array[j], &array[j+1]);
            }
        }
    }
}
int printe(int array[], int n){
    int i;
    for (i = 0; i < n; i++)
        printf("%d ,", array[i]);
    printf("\n Fin del ordenamiento Acsendente \n");
}
int printa(int array[], int n){
    int i;
    for (i = 299; i >= 0; i--)
        printf("%d ,", array[i]);
    printf("\n Fin orden Descendente");
}
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, 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};
    int n = sizeof(array)/sizeof(array[0]);
    bubbleSort(array, n);
    printe(array, n);
    printa(array, n);
    printf("\n");
    return 0;
}

Utilicé el algoritmo de QuickSort

def quickSort(alist):
  quickSortHelper(alist,0,len(alist)-1)

def quickSortHelper(alist,first,last):
  if first<last:
    splitpoint = partition(alist, first, last)
    quickSortHelper(alist, first, splitpoint-1)
    quickSortHelper(alist, splitpoint+1, last)

def partition(alist, first, last):
  pivotvalue = alist[first]
  leftmark = first + 1
  rightmark = last
  done = False
  
  while not done:
    while leftmark <= rightmark and alist[leftmark]<=pivotvalue:
      leftmark = leftmark + 1
    while leftmark <= rightmark and alist[rightmark]>=pivotvalue:
      rightmark=rightmark - 1
    if rightmark<leftmark:
      done = True
    else:
      temp = alist[leftmark]
      alist[leftmark] = alist[rightmark]
      alist[rightmark] = temp
  temp = alist[first]
  alist[first] = alist[rightmark]
  alist[rightmark] = temp

  return rightmark

alist = [-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]
quickSort(alist)
print(alist)```

Logrado, utilice el insertion sort de la clase anterior.

#include <stdio.h>



//Imprimir elementos
void showElements(int cant, int array[]){
	
	int i;
	
	for(i=0;i<cant;i++){
		printf("%d, ", array[i]);
	}
	
	printf("\n");
}


//Ordenamiento de los elementos
void orderElements(int cant, int array[]){
	
	int i, pos, aux;
	
	for(i=0;i<cant;i++){
		
		pos = i;
		aux = array[i];		
		
		while((pos>0) && (array[pos-1] > aux)){
			array[pos] = array[pos-1];
			pos--;
		}
		
		array[pos] = aux;
	}
}


//Funcion principal MAIN

int main(){
	
	int n;
	int myArray[] = {-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};
	n = sizeof(myArray) / sizeof(myArray[0]);					
	
	showElements(n, myArray);
	
	orderElements(n, myArray);
	
	showElements(n, myArray);
	
	
	return 0;
}

Me dio flojera hacer el array por lo tanto sólo hice la función y funciona super:

#include <stdio.h>
#include <math.h>

// Función de insertion Sort Mayor a menor
void insertionSort2(int arr[], int n) {
    int i, currentVal, j;
    for(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;
    }
}

// función auxiliar para imprimir un arrary de tamaño n
int printArr(int arrIn[], int n) {
    for(int i = 0; i < n; i++){
        if(i == n - 1) {
            printf("%d", arrIn[i]);
        } else {
            printf("%d, ", arrIn[i]);
        }
    }
    printf("\nFin del ordenamiento\n");
}

// Driver program to test insertion sort
int main() {
    int arr[] = {6, 4, 3, 11, 10};
    int n = sizeof(arr) / sizeof(arr[0])
    insertionSort2(arr, n);
    printArr(arr, n);
    return 0;
}

Python

def buuble_sort(numbers):
    not_serted = True
    while not_serted:
        #sort
        for idx in range(len(numbers)-1):
            if numbers[idx] > numbers[idx+1]:
                numbers.insert(idx,numbers.pop(idx+1))

        #check if sorted
        for idx in range(len(numbers)-1):
            if numbers[idx] > numbers[idx+1]:
                break
            if idx == len(numbers)-2:
                print(numbers)
                not_serted = False



if __name__ == "__main__":
    buuble_sort(numbers)

Utilicé el algoritmo de InsertionSort en C y lo escribí también en Python. Les dejo ambos códigos:

Código en C

#include <stdio.h>
#include <math.h>

void insertionSort(int arr[], int n)
{
	int i, currentVal, j; 
	for(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, 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 n = sizeof(arr) / sizeof(arr[0]);

	insertionSort(arr, n);
	printArray(arr, n);

	return 0;
}

Código en Python

def insertionSort(array, n):

	currentValue = 0
	for i in range(n):
		
		currentValue = array[i]
		j = i - 1
		
		while j >= 0 and array[j] < currentValue:
			array[j + 1] = array[j]
			j = j - 1

		array[j + 1] = currentValue

def printArray(array, n):
	for i in range(n):
		print(f"{array[i]} ")


def main():

	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]
	n = len(array)
	insertionSort(array, n)
	printArray(array, n)

if __name__ == '__main__':
	main()

Es una combinación de SelectionSort con búsqueda binaria en python

import math

def datos():
    num = []
    with open('numeros.txt', 'r') as t:
        for line in t:
            num.append(int(line))

    return num


def run():
    num = datos()
    print(num)
    orden = 0

    for i in range(1, len(num)):
        bajo = 0
        alto = orden
        c = math.floor((bajo + alto) / 2)

        while True:
            if num[i] < num[0] or num[i] > num[orden]:
                if num[i] < num[0]:
                    num.insert(0, num[i])
                    del num[i + 1]
                orden += 1
                break

            if num[i] >= num[c]:
                bajo = c
            else:
                alto = c
            c = math.floor((bajo + alto) / 2)

            if alto - bajo == 1:
                num.insert(alto, num[i])
                del num[i + 1]
                orden += 1
                break
    print(num)


if __name__ == '__main__':
    run()

Decidí aplicar ambos algoritmos y contar la cantidad de iteraciones, para ello tuve que crear dos arreglos con la misma información, esto con el objetivo de ordenar el mismo arreglo sin alteraciones.
Dado el conteo, parece ser que el insertionSort es el más eficiente de los dos.

/* Este programa implementara ambos algoritmos de ordenamiento estudiados hasta ahora
bubbleSort e insertionSort se pondra un contador adentro de cada iteración del algoritmo y devolvera
el número de veces que se hace una iteración.
El algoritmo ordenara los elementos del arreglo en orden ascendente.*/
#include <stdio.h>
#include <math.h>

int itBubble = 0, itInsertion = 0;

void printArray(int arr[], int n)
{
	int i;
	printf("\n");
	for (i = 0; i < n; i++)
	{
		printf("[%d]", arr[i]);
		if(i != 0 && i % 10 == 0)
			printf("\n");
	}
	printf("\n\n");
}

//InsertionSort
void insertionSort(int arr[], int n)
{
	int i, j, currentVal;
	for (i = 0; i < n; i++)
	{
		currentVal = arr[i];
		j = i-1;
		while (j >= 0 && arr[j] > currentVal) 
	   	{ 
			arr[j+1] = arr[j]; 
	        j = j-1;
	        itInsertion++; //Aumenta la iteración del insertionSort. 
	    } 
	    arr[j+1] = currentVal;
	    itInsertion++;  //Aumenta la iteración del insertionSort. 
	}
}

//BubbleSort
void swapPos(int *n1, int *n2)
{
	int temp = *n1;
	*n1 = *n2;
	*n2 = temp;
}

void bubbleSort(int arr[], int n)
{
	int i, j;
	for (i = 0; i < n-1; i++)
	{
		for (j = 0; j < n-i-1; j++)
		{
			if(arr[j] > arr[j+1])
				swapPos(&arr[j], &arr[j+1]);
			itBubble++; //Aumenta la iteración del bubbleSort. 
		}
	}
}

int main(int argc, char const *argv[])
{
	int arr1[] = {-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};

	int arr2[] = {-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};

	int n1 = sizeof(arr1)/sizeof(arr1[0]);
	int n2 = sizeof(arr2)/sizeof(arr2[0]);

	printf("Ordenar un arreglo usando los algoritmos de bubbleSort e insertionSort en orden acendente.\n\n");
	printf("Numero de elementos: %d.\n\n", n1);

	printf("Arreglo original: ");
	printArray(arr1, n1);

	printf("Arreglo ordenado con bubbleSort: ");
	bubbleSort(arr1, n1);
	printArray(arr1, n1);

	printf("Arreglo ordenado con insertionSort: ");
	insertionSort(arr2, n2);
	printArray(arr2, n2);

	printf("Cantidad de iteraciones bubbleSort: %d.\n", itBubble);
	printf("Cantidad de iteraciones insertionSort: %d.\n", itInsertion);

	return 0;
}

Reto cumplido con el uso de C++;

#include <iostream>

using namespace std;
void insertionSort(int arr[], int n)
{
    int i, currenVal, j;
    for (i =1; i <n; i++)
    {
        currenVal = arr[i];
        j = i-1;
        while(j>= 0 && arr[j]< currenVal)
        {
            arr[j+1] = arr[j];
            j = j-1;
        }
        arr[j+1]=currenVal;
    }
}
void ChangePosition(int *n1, int *n2)
{
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
void bubblesort(int arr[],int n)
{
    int i,j;
    for(i=0; i<n-1; i++)
    {
        for(j=0; j<n-i; j++)
        {
            if(arr[j]<arr[j+1])
            {
                ChangePosition(&arr[j],&arr[j+1]);
            }
        }
    }
}

void printArray(int arr[], int n)
{
    int i;
    for(i=0; i<n; i++)
    {
        cout<<"|"<< arr[i];
    }
    cout <<""<< endl;
    cout<<"fin del ordenamiento"<<endl;
}

int main()
{
    string t = " ";
    bool q = true;
    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, 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};
		 int n = sizeof(arr)/sizeof(arr[0]);

    cout << "ingrese a si quiere ordenar con insertion o s para ordenar con bubble" <<endl;

    while(q == true)
    {
        cin >> t;
        if(t == "a")
        {
            insertionSort(arr,n);
            printArray(arr,n);


        }else if(t == "s")
        {
            bubblesort(arr,n);
            printArray(arr,n);

        }else
        {
             q = false;

        }

    }

    return 0;
}```

# Crear una memoria de numeros.
numbers = []

# Abrir el archivo con los numeros.
file = open("numbers.txt")

# Por cada linea agregar a la coleccion su resultado en entero.
for line in file.readlines():
    numbers.append(int(line))

# Organizacion de tipo burbuja.
def bubbleSort(array: list):
    # Reconocer la longitud del arreglo.
    array_length = len(array)
    # Reciclar la longitud.
    for _ in range(array_length - 1):
        for i in range(array_length - 1):
            temp = array[i]
            if (array[i] > array[i + 1]):
                array[i] = array[i + 1]
                array[i + 1] = temp
    return array

bubbleSort(numbers)

# Imprimir la lista
print(*numbers, sep='\n')```

Puse el archivo de los números en un texto, y luego lo parsee a una lista de enteros.

#include <stdio.h>


/*Metodo de ordenamiento*/
void insertionSort(int *array, int n)
{
	int i, currentVal, j; 
	for (i = 1; i < n; i++) 
	{ 
		currentVal= array[i];
		j = i - 1;
		while (j >= 0 && array[j] > currentVal) 
		{ 
			array[j + 1] = array[j]; 
			j = j - 1; 
		} 
		array[j + 1] = currentVal; 
	} 
	
}

/*Imprimiendo matriz*/
void printArray(int *array, int n)
{
	for (int i = 0; i < n; i++)
	{
		if (i == (n - 1))
			printf("%d\n", array[i]);
		else
			printf("%d ,",array[i]);
	}
	printf("Fin del ordenamiento\n");
}

/*Metodo main*/
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-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 n = sizeof(array) / sizeof(array[0]);

	insertionSort(array, n);
	printArray(array, n);
	return (0);
}

Aquí mi solución. Implementé Insertion-Sort en C, gracias al Curso de Introducción a C

![](

![](

Pueden bajar el código de aquí: https://github.com/jcalvarezj/practice/blob/master/C/insertionData.c

Para este desafío use dos métodos distintos y en dos lenguajes diferentes C y JS:

En C

#include "stdio.h"

void organizar(int Array[], int Length)
{
    int j, a, temp;
    for (j = 0; j < Length; j++)
    {
        for(a=j+1; a < Length; a++)
        {
            if (Array[j] < Array[a])
            {
                temp = Array[j];
                Array[j]=Array[a];
                Array[a]=temp;
            }
        }
    }
}

void imprimir(int Array[], int Length)
{
    int i;
    for (i = 0; i < Length-1; i++)
    {
        printf("%d, ",Array[i]);
    }
    printf("%d.",Array[Length-1]);
    
}

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 Length = sizeof(Array)/sizeof(Array[0]);

    organizar(Array, Length);
    imprimir(Array, Length);

    return 0;
}

Y en JS:

var Numeros=[-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];

var largo = Numeros.length;
var temp, cont;
var conf = true;

BubbleSort();
imprimir();

function BubbleSort()
{
    while(conf)
    {
        cont = 0;
        for (var i = 0; i < largo-1; i++)  
        {
            if (Numeros[i]<Numeros[i+1])
            {
                temp = Numeros[i];
                Numeros[i] = Numeros[i+1];
                Numeros[i+1] = temp;
                cont ++;
            }
            console.log(cont+" "+conf)
        }
        if (cont == 0)
        {
            console.log(cont+" Entro al if")
            conf = false;
        }
    }
}

function imprimir()
{
    var escribir = document.getElementById('orden');
    escribir.innerHTML = Numeros;
}