Bubble sort: implementación

Acá una prueba de escritorio de la implementación del doble for en la función bubbleSort(): Lo que hace esta implementación es ubicar los elementos de mayor valor al extremo del arreglo en cada iteración del for anidado.

La condición del segundo for j < n - i - 1 reduce el número de comparaciones en cada iteración. Con esto ya no se comparan los elementos ya ordenados a la derecha del arreglo, es decir, los elementos mayores. En cada iteración, el elemento mayor de la parte del arreglo que aún no está ordenada se coloca en su posición.

Fue util haber hecho el curso de Introducción a Lenguaje C antes de venir aquí.

IMPORTANTE AL HABLAR DE BURBUJA recuerden que para el ordenamiento de la burbuja vamos a tener que guardar el valor cada que hagamos una iteración en una variable temporal porque necesitamos poder guardarlo mientras hacemos el cambio.

En bubble sort cuando estamos ordenando de forma asc, despues de cada recorrido completo del array tendremos al menos el ultimo valor de la lista ordenado. Es por esto que en el segundo ciclo no se debe recorrer hasta el final sino hast final-numeroDeIteracionesAnteriores.

function bubbleSort(sortedList = []) {
    const length = sortedList.length;
    
    for (let i = 0; i< length - 1; i++) {
        for (let j=1; j<length-i; j++) {
            if (sortedList[j-1] > sortedList[j]) {
                const swap = sortedList[j-1];
                sortedList[j-1] = sortedList[j];
                sortedList[j] = swap;
            }
        }
    }

    return sortedList;
}

function sort() {
    let list = [4,2,6,8,1,5];
    console.log(`Unsorted List: ${list}`);
    // Desordered List: 4,2,6,8,1,5
    console.log(`Sorted List: ${bubbleSort([...list])}`);
    // Sorted List: 1,2,4,5,6,8
}

sort();

Ejemplo realizado con Angular, que muestra en pantalla el proceso que se llevó a cabo para ordenar el array.

https://stackblitz.com/edit/vgmva1-bubble-order

Lo hice antes de ver el video, y con un menú. Me quedó así:
bubblesort.c

#include <stdio.h>
#include "bubblesort-func.h"

void menu(){
	int option=0;
    do{
        printf("\n-------------------------------\n");
        printf("            BUBBLE SORT :D\n");
        printf("1. Llenar o sobreescribir el array\n");
        printf("2. Imprimir el contenido del array\n");
        printf("3. Organizar el array\n");
        printf("4. Salir\n");
        printf("-------------------------------\n");
        printf("Digite su opción:");
        scanf("%i", &option);
		printf("\n");
		
        switch(option){
            case 1:
                getArray();
            break;
            case 2:
                printArray();
            break;
            case 3:
                bubbleSort();
            break;
            case 4:
                printf("Gracias por usar :D");
            break;
            default:
                printf("Opción inválida");
        }
		if((option != 1) && (option != 2)){
			printf("\n");
		}
    }while(option != 4);
}

int main(){
    menu();

    return 0;
}

bubblesort-func.h

int array[0];
int sizeArray=0;

void printArray(){
	if(sizeArray == 0){
		printf("Array vacío, no se puede imprimir :c\n");
	}else{
		for(int i=0; i<sizeArray; i++){
			printf("Array[%i] = %i\n", i, array[i]);
		}
	}
}

void getArray(){
    printf("Digite el tamaño de su array: ");
    scanf("%i", &sizeArray);
    
    for(int i=0; i<sizeArray; i++){
        printf("Digite el valor de la posición %i en su array: ", i);
        scanf("%i", &array[i]);
    }
}

void mayorMenor(){
    int casos=1;
    while(casos != 0){
        casos=0;
    	for(int i=0; i<sizeArray-1; i++){     //Se recorre hasta sizeArray-1 porque si llega hasta sizeArray se compara con sizeArray+1 (que sería un espacio vacío, un 0)
    	    if(array[i+1] < array[i]){
    	        int temp = array[i];
    	        array[i] = array[i+1];
    	        array[i+1] = temp;
    	        casos++;
    	    }
    	}
    }
}

void menorMayor(){
	int casos=1;
    while(casos != 0){
        casos=0;
    	for(int i=0; i<sizeArray-1; i++){
    	    if(array[i+1] > array[i]){
    	        int temp = array[i];
    	        array[i] = array[i+1];
    	        array[i+1] = temp;
    	        casos++;
    	    }
    	}
    }
}

void bubbleSort(){
	if(sizeArray == 0){
		printf("Array vacío, no se puede organizar :c");
	}else{
		int option=0;
		printf("1. De mayor a menor\n");
		printf("2. De menor a mayor\n");
		printf("Opción:");
		scanf("%i", &option);
		
		switch(option){
			case 1:
				mayorMenor();
			break;
			case 2:
				menorMayor();
			break;
			default:
				printf("Opción inválida");
		}
	}
}

El mejor porfesor para explicar es Freddy, por lejos!

For comparison purposes in an array, two adjacent cells are needed; in an array of 6 elements, only 5 comparisons take place; in an array of 10 elements, 9 comparisons, and so on.

So for 7 elements, just 6 comparisons are done, hence the general rule of n-1 in the outer for loop

About the n-1-i expression, remember that the highest (or lowest, depending on the ordering criterion) value in the bubble sort goes to the last position in the array after the first cycle, so there is no need to compare that value with anything else, therefore the array has to be “shortened” 1 cell at a time, and the value of i in the outer loop is the counter responsible for that in the inner loop:

5 | 3 | 9 | 20 | elements (n) = 4

after first cycle (i = 0), 20 has reached its correct position within the array (using an ascending order), leaving us with an array of 3 elements; in next cycle, i will be equal to 1, and as n-1 remains the same, we need to substract 1 in that expression to “shorten” the array:
n-1-i = 4-1-1 = 2, which is the index of the last element in that new array as well as the quantity of comparisons needed.

aquí esta mi solucion en python

# Definicion de variables
numbers_array = [4, 2, 3, 6, 1, 5]
esta_ordenado = False


def ordenar_array(list):
    global esta_ordenado
    # imprime el arreglo original
    print("Arreglo original\n")
    for x in list:
        print(x, end=' ')
    print("\n")

    # algoritmo de ordenamiento
    while not esta_ordenado:
        # ciclo de ordenamiento
        for x in range(0, 5):
            if list[x] > list[x + 1]:
                temp = list[x]
                list[x] = list[x + 1]
                list[x + 1] = temp
        # ciclo de verificacion
        for x in range(0, 5):
            if list[x] > list[x + 1]:
                esta_ordenado = False
                break
            else:
                esta_ordenado = True

    print("Arreglo ordenado\n")
    for x in list:
        print(x, end=' ')
    print("\n")


if __name__ == "__main__":
    ordenar_array(numbers_array)

Resultado

Arreglo original

4 2 3 6 1 5 

Arreglo ordenado

1 2 3 4 5 6 

Mi implementación en Java

class Main {
  public static void main(String[] args) {
    int[] array = {5,8,9,2,1};
    for(int i=0; i<array.length; i++)
      for(int j=0; j<array.length; j++)
        if(j+1<array.length)
          if(array[j]>array[j+1]){
            int temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
          }
    
    for(int x=0; x<array.length; x++)
      System.out.println(array[x]);
  }
}

Les comparto un video de bubble sort, muy practico y entendible tambien para reforzar la clase: https://www.youtube.com/watch?v=P_xNb8nFgmA&ab_channel=ProgramaciónATS

Bien pobre la explicacion del profesor sobre como funciona la logica del j < n - i - 1 en el for anidado. 👎

Aquí mi código en python:

def bubbleSort(messy_list):
  print("Ordenando..")
  for _ in range(len(messy_list)):
    for i in range(len(messy_list)-1):
        left = messy_list[i]
        right = messy_list[i+1]
        if left > right:
          messy_list[i] = right
          messy_list[i+1] = left

  return messy_list


if __name__ == '__main__':
  messy_list = [5,9,2,6,1,3,7,8]
  print(messy_list)
  ordered_list = bubbleSort(messy_list)
  print(ordered_list)

La explicación del bubblesort se me hizo muy enredada por lo que ayudándome con este video y probando pude entenderlo a la perfección. Si alguien quiere que lo ayude con gusto estoy 😉

https://www.youtube.com/watch?v=Jdtq5uKz-w4&t=430s

Punteros en C

excelente, el curso, con cierto grado de dificultad para los novatos como uno. Se presuponen muchos a-prioris que para la gente formada en otras áreas del conocimiento (lengua y literatura hispánica, que es mi caso), que deben ser dilucidados antes de continuar. Todo este proceso me encanta, pero me confronta y me reta a llenar esos vacíos de conocimiento. Días pasan para que en algunos cursos pueda seguir avanzando. Mi poca experiencia la he adquirido en excel: tablas, funciones, datos, macros, y un poco de VB, y en este curso de algoritmos comienzo a entender el pleno funcionamiento de la ofimática de excel. Gracias

Código en JavaScript

let array = [2,4,1,5,3];
let aux;

//Booble sort
for(let i = 0; i<5; i++){
  for(let j = 0; j<5; j++){
    if(array[j]>array[j+1]){
      aux = array[j];
      array[j] = array[j+1];
      array[j+1] = aux;
    }
  }
  console.log(`Iteracion ${i+1}: ${array}`);
}
console.log(`Resultado final -> ${array}`);

Esta es mi implementación en JS

function bubbleSort(array){
    let n=array.length;
    console.log(n);

    for(let i=0;i<n-1;i++){
        for(let j=0;j<n-1-i;j++){
            [array[j],array[j+1]]=compare(array[j],array[j+1]);
        }
    }
    
}
function compare(num1, num2){
    if(num1<=num2){
        return [num1,num2]
    } else{
        return [num2,num1]
    }
}```

#include <stdio.h>

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

void bubblesort(int vector_entrada[], n)
{
    int i, j;
    for(i=0; i < n-1; i++)
    {
        for (j = 0; j < n-i-1; j++)
        {
            if (vector_entrda[j]>vector_entrada[j+1])
            {
                cambiar_posicion(&vector_entrada[j],&vector_entrada[j+1]);
            }
            
        }
        
    }
}```

Mi solución

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

void sort(int array[]){
    int cantidadEspacios = sizeof(array);
    bool completado = false;

    for(int i = 0;i < cantidadEspacios;i++){
        printf(" [%d] ",array[i]);
    }
    int cantidadEspaciosParaImprimir = cantidadEspacios;
    printf("\n");
    int contador = 1;
    int temp;
    do{
        for(int i = 0;i < cantidadEspacios - 1;i++){
            if(array[i] > array[i + 1]){
                temp = array[i];
                array[i] = array[i+1];
                array[i+1] = temp;
            }
        }
        printf("Vuelta n° %d", contador);
        for(int i = 0;i < cantidadEspaciosParaImprimir;i++){
            printf(" [%d] ",array[i]);
        }
        printf("\n");
        cantidadEspacios--;
        contador ++;
    }while(cantidadEspacios > 0);
}

int main(){
    int array[] = {1,5,3,8,9,3,1,4};
   sort(array);
    int cantidadEspacios = sizeof(array)/sizeof(array[0]);
    printf("Array ordenado\n");
    for(int i = 0;i < cantidadEspacios;i++){
        printf(" [%d] ",array[i]);
    }
    return 0;
}

En python3.

import random

def cambiar_pos(x,y):

	temp = x
	n1 = y
	n2 = temp
	return n1, n2


def bubble_sort(array):
	n = len(array)

	for i in range(n):
		for j in range(n-i-1):
			if array[j] > array[j+1]:
				array[j], array[j+1] = array[j+1], array[j]

lista = [x for x in range(100)]
random.shuffle(lista)
print(lista)

bubble_sort(lista)
print(lista)```

#include <stdio.h>


// Funcion que hace swap a dos dirreciones enteras de memoria
void cambiar_pos( int *n1, int *n2 ) {
  // Almacenar un cambio
  int temp = *n1;
  *n1 = *n2;
  *n2 = temp;
}

// Implementacion del algoritmo de bubble sorrt
void bubbleSort( int vector_entrada[], int n) {
  // Para que no lo calcule cada vez que entra al ciclo
  int tamano = n - 1;

  // Por cada valor del arreglo
  for ( int i = 0; i < tamano; i++) {
    int ciclos = n - i - 1;

    // Recorriendo, menos los ultimos porque
    // esos ya estan ordenados
    for ( int j = 0; j < ciclos; j++ ) {

      // Hacer swap en caso de que dos valores esten en desorden
      if ( vector_entrada[j] > vector_entrada[ j + 1 ] ) {
        cambiar_pos( &vector_entrada[j], &vector_entrada[ j + 1 ] );
      }
      
    }
  }

}

Una version diferente en C
Con Do-While y que permite recibir los numeros del array mediante standard input por consola

Reto Solucionado

<code>
//Bubble sort
//1-Comencamos a hacer la coparacion de elementos adyacentes
//2-Repetimos hasta tener una pasada completa sin ningun swap


#include <stdio.h>
#include <stdlib.h>

void cambiar_pos(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]){
                cambiar_pos(&vector_entrada[j],&vector_entrada[j+1]);
            }
        }
    }
}

 void bubbleSortMayor(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]){
                cambiar_pos(&vector_entrada[j],&vector_entrada[j+1]);
            }
        }
    }
}

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

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

int vector_entrada[]={100, 1992, 0, 5, -1, 60, 70, 14, 15, 10};
int n = sizeof(vector_entrada)/sizeof(vector_entrada[0]);
bubbleSort(vector_entrada, n);
print_array(vector_entrada, n);
bubbleSortMayor(vector_entrada, n);
print_array(vector_entrada, n);
printf("\n");


return 0;
}

Muy bien detallado.

Mi implementación con Javascript.

function orderNumbers(inputs){
    let isInOrder = true
    do{
        isInOrder = true
        for(let i=0; i<inputs.length; i++){
            if(inputs[i]> inputs[i+1]){
                let aux = inputs[i]
                inputs[i] = inputs[i+1]
                inputs[i+1] = aux
                isInOrder = false
            }
        }
    }while(isInOrder === false)
}

Aquí les va mi código en python! A mi se me ocurrió utilizar un While y un For 😃

def interchange(array_entrada, num_1, num_2):
    """This function executes and interchange of values of a given array.    

    Args:
        array_entrada ```list``` : The array in which the movements are to be made.
        num_1 ```int``` : The first position of the array to be interchanged.
        num_2 ```int``` : The second position of the array to be interchanged.
    
    Returns:
        array_entrada ```list``` : The array with interchanged positions
    
    Example:
    
    >>> array_entrada = [4, 2, 32, 1], num_1 = 0, num_2 = 1
    array_salida = [2, 4 , 32, 1]
    """

    temp = array_entrada[num_1]    
    array_entrada[num_1] = array_entrada[num_2]
    array_entrada[num_2] = temp
    return array_entrada

def bubble_sort(array_entrada):
    """
    This function executes the Bubble Sort algorithm on the given array.    

    Args:
        array_entrada: ```list``` = An unordered List of floating or integer numbers.
    
    Returns:
        array_salida: ```list``` = A sorted List of floating or integer numbers
    
    Example:
    
    >>> array_entrada = [4, 7, 32, 1]
    array_salida = [1, 4, 7, 32]
    """
    array_salida = array_entrada
    # is_sorted serves as a flag for our algorithm to exti the sroting function inside the while.
    is_sorted = False
    while is_sorted == False:
        # is_sorted flag will stay True if there are no needd
        is_sorted = True
        n = len(array_salida)
        for i in range(0, n-1):
            print("Checando la posicion: " + str(i))
            if array_salida[i] > array_salida[i+1]:
                is_sorted = False   
                print("Reacomodando... ")
                array_salida = interchange(array_salida, i , i + 1)
            print(array_salida)
    return array_salida 


def main():
    array_entrada = [5,34,23,3,2,8,8]
    bubble_sort(array_entrada)

if __name__ == '__main__':
    main()```

Buena clase!

Explicacion de codigo:

Codigo:



#include<stdio.h>
void cambiar_pos(int *n1, int *n2){#Funcion de cambio de valores
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
void bubbleSort(int array[], n){
    int i;
    int j;
    for(i = 0; i < n-1; i++){#Ciclos totales
        for(j = 0; j < n-i-1; j++){#Recorrido del array
            if(array[j]>array[j+1]){
                cambiar_pos(&array[j], &array[j+1])#Comparacion de numeros
            }
        }
    }
}
#j+1, significa el numero siguiente en el array
#n -i -1 Es para ubicarse en la posicion correcta del array deacuerdo a su posición```

Interesante como estructuró las funciones! 🤯

#include<stdio.h>

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

void bubbleSort(int vector_entrada[], 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])
            cambiar_pos(&vector_entrada[j],&vector_entrada[j+1])
        }
    }
}```

Código en JS:

Realize mi ejemplo con un ejercicio de java que trabaje en la escuela, aun no domino los términos correctos pero espero a alguien le pueda servir y claro, puedan hacer mejoras 😁👍

//clase main
 Busqueda<Integer> busqueda2 = new Busqueda<>();
        System.out.println(Arrays.toString(arreglo));
        busqueda2.bubbleSort(arreglo);
        System.out.println(Arrays.toString(arreglo));

//clase de busqueda
public class Busqueda<T extends Comparable> {
public void bubbleSort(T[] array) {
        T valor_temp;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if (j + 1 < array.length) {
                    if (array[j].compareTo(array[j + 1]) > 0) {
                        valor_temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = valor_temp;
                    }
                }
            }
        }
    } 
}

Con python Me base en la respuesta de aarongabriel420, con un par de mejoras al momento de imprimir el array desordenado y el ordenado. También coloque una mejora para que el ciclo for se ejecute dependiendo del largo de la lista, ya no es necesario colocar el dato de range de forma manual:

<array = [2,8,1,6,3,9]
esta_ordenado= False

def ordenar_lista(lista):
    # imprimir arreglo original
    print("arreglo original\n")
    print(lista,"\n")

    global esta_ordenado

    #algoritmo de ordenamiento
    while not esta_ordenado:  

        for n in range(0, len(lista) - 1):
            if lista[n] > lista[n + 1]:
                vtemp = lista[n]
                lista[n] = lista[n + 1]
                lista [n + 1] = vtemp

        for n in range(0, len(lista) - 1):
            if lista[n] > lista[n + 1]:
                esta_ordenado = False
                break
            else:
                esta_ordenado = True

    print("arreglo ordenado\n")
    print(lista,"\n")

ordenar_lista(array)>

Resultado :

arreglo original

[2, 8, 1, 6, 3, 9]

arreglo ordenado

[1, 2, 3, 6, 8, 9]

Ejemplo en javascript

este es mi bubble sort:

import logging
logging.basicConfig(level=logging.INFO)
#lista=[5,4,3,2,1,7,19,2,100,4,22,11,15]
lista=[13,12,11,10,9,8,7,6,5,4,3,2,1]
def order(lista,first):
    if lista[first]>lista[first+1]:
        menor=lista[first+1]
        mayor=lista[first]
        lista[first]=menor
        lista[first+1]=mayor
        return lista
    else:
        return lista
def bubble_bucle(lista):
    for a in range(len(lista)-1):
        logging.info('entrando a order')
        for first in range(len(lista)-1):
            lista=order(lista,first)
            logging.info(str(lista))
    return lista
lista=bubble_bucle(lista)
logging.info('la lista es {}'.format(str(lista)))```

Siento que entiendo pero no con totalidad, creería que es porque debo seguir practicando.

Buena explicación, es complejo al comienzo pero con práctica y analizando cada procedimiento cada vez es más entendible.

creo que se debe seguir practicando ya que es la primera vez que interactuo con este procedimiento

Creo que para el ejemplo se debe de dejar una lectura para entender lo que es el paso por valor y el paso por referencia porque en la implementación se usa directamente sin explicar el porqué.

def bubble_sort(size):
    list = [random.randint(0, 1000) for n in range(size)]
    n = len(list)

    for i in range(n):
        for j in range(0, n - 1):
            if list[j] > list[j + 1]:
                list[j], list[j + 1] = list[j + 1], list[j]
        return list

me perdí un poco, por qué las variables n1 y n2 van con un * antes?

ordenamientos directos(basicos)
selección, inserción, burbuja (ineficientes para grandes cantidades de datos)
ordenamientos indirectos(avanzados)
shell, quick sort, merge sort, radix sort.

un pequeño aporte que no dicen en este curso

Mi versión.

#include <stdlib.h>
#include <stdio.h>

void sort(int array[], size_t size)
{
	unsigned short sorted = 0;
	int tmp = 0;

	for (int x = 0; x < size - 1; x++)
	{
		for (int i = 0; i < size - x - 1; i++)
		{
			if (array[i] > array[i + 1])
			{
				tmp = array[i];
				array[i] = array[i + 1];
				array[i + 1] = tmp;
				sorted = 1;
			}
		}

		// Break the loop if no swaps has been performed
		if (!sorted)
			break;
		sorted = 0;
	}
}

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


int main(const int argc, const char *argv[])
{
	int a[] = {11, 5, 4, 1, 3, 200, 6, 600, 1, 7, 29, 22, 9, 300};
	size_t size = sizeof(a)/sizeof(a[0]);

	display_array(a, size);
	sort(a, size);
	display_array(a, size);

	return 0;
}

Mi ejemplo de bubble sort en JavaScript

const items = [5, 2, 4, 2, 100, 7, 1, 3, 50]

for (let i = 0; i < items.length; i++) {
  for (let j = 0; j < items.length - 1; j++) {
    if (items[j] > items[j + 1]) {
      const element = items[j]
      items[j] = items[j + 1]
      items[j + 1] = element
    }
  }
}

No me queda del todo claro porque hace n-i-1

Código en Java:

public void BubbleSort(int arreglo[])
{
	for (int i=0; i<arreglo.length-1; i++)
		for (int j=0; j<arreglo.length-i-1; j++)
			if (arreglo[j] > arreglo[j+1])
			{
				int temp = arreglo[j];
				arreglo[j] = arreglo[j+1];
				arreglo[j+1] = temp;
			}
}

void BubbleSort(int* numeros){

    int continueLoop = 1;
    for(int i = 0; i < MAX; i++){
            if(continueLoop){
                continueLoop = 0;
                for(int y = 0; y < MAX - 1; y++){
                    if(numeros[y] > numeros[y + 1]){
                        swapNumbers(numeros[y], numeros[y + 1]);
                        continueLoop = 1;
                    }
                }
            }
            else{
                return;
            }
    }
}

void swapNumbers(int a, int b){
    int aux = 1;
    aux = a;
    a = b;
    b= aux;
}

I’m using the variable continueLoop because I want to know if there are not changes into a loop, if there are not I don’t want to continue looping the double for, that means that my array is sorted

Todo esto funciona exactamente igual si uso números flotantes?

muy entendible.

Comparto otra propuesta para implementar el algoritmo bubble sort con una sola función. Uso una variable para detectar cuando se dejan de producir cambios (es decir la secuencia ya está en orden) y un ciclo do while que se ejecute mientras encuentre algún cambio. Lo demás es una simple comparación de los datos del vector mediante un ciclo for

#include <stdio.h>
#include <string.h>
#define size 10

int vector[size]={2,43,45,87,9,0,-2,34,-10,-10};

void bubbleSort(int array[]){
  int change=0;
  int aux=0;
  do{
    change=0;
    for (int i=1;i<size;i++){
      if(array[i-1]>array[i]){
        aux=array[i];
        array[i]=array[i-1];
        array[i-1]=aux;
        change=1;
      }
    }
  }while (change!=0);
}

Comparto uno que hice en javascript. Salu2

var values = [7,2,3,2,5,4,5,9,8,1,2,6,8,4]


function bubblesort(numberOfValues){
  for(i=0;i<numberOfValues;i++){
    var p = 0;
    while(p<numberOfValues){
      var firstCounter=p;
      var secondCounter=p+1;
      var firstValue=values[firstCounter];
      var secondValue=values[secondCounter];
      if(firstValue>secondValue){
        values[firstCounter]=secondValue;
        values[secondCounter]=firstValue;
      }
      p++;
    }
  }
  return values;
}

console.log(bubblesort(values.length));

thanks!

Alguien lo hizo en Python?

Graxias

Importante saber hacer código en varios lenguajes.

#Codigo en Python
def cambiar_pos(n1,n2):
	n1,n2 = n2,n1

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

Muy bien!

![](

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void cambiar(int *a, int *b){
    *a = *a ^ *b;
    *b = *a ^ *b;
    *a = *a ^ *b;}

void bubbleSort(int *arreglo,const short tam){
    short i,j;
    for(i = 0; i < tam; ++i){
        for(j = 0; j < tam -1; ++j){
            if(arreglo[j] > arreglo[j + 1])
                cambiar(&arreglo[j],&arreglo[j+1]);}}}

void imprime (int *arreglo,const short dimencion){
    short i;
    for(i = 0;i <dimencion; ++i)
        printf(" %d |",arreglo[i]);
    printf("\n\n");}
int main(void)
{
    srand(time(NULL));
    short dimencion = 20;
    short i;
    int arreglo[dimencion];
    for(i = 0; i < dimencion; ++i)
        arreglo[i] = rand()%100+0;
    printf("Sin ordenar:\n\n");
    imprime(arreglo,dimencion);
    bubbleSort(arreglo,dimencion);
    printf("Ya ordenado:\n\n");
    imprime(arreglo,dimencion);
    return 0;
}```

Me gustaron este tipo de ejercicios, sobre todo para entender la lógica del proceso.

var numbersArray = [9,5,4,6,7,2,1,10,0,5];

let bubbleSort = (newArray) => {
    let position = newArray.length;
    for (let i = 0; i < position; i++) {
        for (let j = 0; j < position; j++) {
            if (newArray[j] > newArray[j + 1]) {
                let tmp = newArray[j];
                newArray[j] = newArray[j + 1];
                newArray[j + 1] = tmp;
            }
        }
    }
    return newArray;
};

console.log(bubbleSort(numbersArray));```

Lo intenté implementar para que no fuera necesario pasarle el tamaño del array en la variable n.

#include <stdio.h>
#include <stdlib.h>

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

void bubblesort(int array[]){
	int isSorted = 0;
	int i = 0;
	int lenght = sizeof(array) / sizeof(array[0]);
	while(isSorted == 0){
		isSorted = 1;
		for(i = 0; i < lenght - 1; i++){
			if(array[i] > array[i + 1]){
				changePos(&array[i], &array[i + 1]);
				isSorted = 0;
			}
		}
	}
}
int main(){
	int array[] = {5,6,9,5,69,15,36,25,14,25,23};
	int lenght = sizeof(array) / sizeof(array[0]);
	int i;

	bubblesort(array1);

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

	return 0;
}

La función sizeof() te devuelve el tamaño en bytes del dato que le pases. Por ejemplo en la función main para hallar el lenght se debe dividir el tamaño (en bytes) de todo el array entre el tamaño de lo que ocupa cada posición del array. Entonces, sizeof(array) = 44 y sizeof(array[0]) = 4, por lo que lenght = 11, lo cual es correcto.
Pero en la función bubblesort() sizeof(array) = 8, lo que hace que falle todo el programa. No sé por qué pasa esto 😕
Así que por el momento lo dejaré de esta forma

#include <stdio.h>
#include <stdlib.h>

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

void bubblesort(int array[], int n){
	int isSorted = 0;
	int i = 0;
	while(isSorted == 0){
		isSorted = 1;
		for(i = 0; i < n - 1; i++){
			if(array[i] > array[i + 1]){
				changePos(&array[i], &array[i + 1]);
				isSorted = 0;
			}
		}
	}
}
int main(){
	int array[] = {5,6,9,5,69,15,36,25,14,25,23};
	int lenght = sizeof(array) / sizeof(array[0]);
	int i;

	bubblesort(array, lenght);

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

	return 0;
}

Amigos, yo hice un ejercicio de Bubble Sort incluso antes de siquiera saber que esa era su nombre. El código esta en el siguiente enlace
https://platzi.com/tutoriales/1469-algoritmos/9226-mi-ejemplo-de-bubble-sort/

¿Que para que sriven los asterizcos?
Se llaman punteros y guardan o “apuntan” a una direccion en memoria.
¿Porque no usar simples referencias como: int a?
Imagina la siguiente funcion:

int suma(int a, int b){
	return a + b;
}
int resultado = suma (20, 6);

Cuando llames a esta funcion tendras que asignar el valor devuelto a una variable.

En cambio con los punteros puedes operar directamente en el espacio de memoria al que apuntan. Ejemplo:

void suma (int* a, int* b, int* c){
	*c = (*a + *b);
}

De este modo no tienes que retornar nada, ni asignarle el valor devuelto a una nueva variable.
¿Cual es exactamente la diferencia entre un puntero y una variable?
Las variables tienen una direccion fija; es decir no cambian.

int x = 20;
int y = 10;
int * puntero;
x = y;
//el operador & devuelve una direccion en memoria
//aqui puntero apunta a la dirección de x
puntero = &x;
printf("Dirección de memoria de x: %p\n", puntero);
//ahora puntero no cambio de valor, "saltó" a otra dirección
puntero = &y;
printf("Dirección de memoria de y: %p\n", puntero);

si ejecutas el codigo anterior en main, veras que imprimira 2 direcciones de memoria diferentes.

Por el momento este es el código que tengo del programa (prefiero poner todo en inglés como mejor práctica:

#include <stdio.h>

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

void bubbleSort(int entry_Vector[],n)
{
    int i, j;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(entry_Vector[j]>entry_Vector[j+1])
            {
                change_pos(&entry_Vector[j],&entry_Vector[j+1]);
            }
        }
    }
}

mi pequeño aporte, implementacion en pyton:

<code>
## ordena burbuja::
def burbuja(vct):
    cambios=1 # inicializo/ simula un do-while
    while cambios>0: # repite hasta que no haya cambios de posicion en el vector
        cambios=0
        for i in range(len(vct)-1):
            #print("pares a comparar:" ,vct[i],vct[i+1])
            if vct[i]>vct[i+1]:
                cambios += 1
                swap_element(vct,i)
            #print('swaped paris:',vct[i],vct[i+1] )

def swap_element(vct,i):
    mayor=vct[i] # mayor a variable auxiliar
    vct[i]=vct[i+1] # menor a posicion antes
    vct[i+1]=mayor # mayor a posicion despues

Este es mi código en Python

#include<iostream>
#include<conio.h>

using namespace std; 

int main() {

	int numeros[5] = {4,1,2,3,5};
	int j, i, cambio;

	//algoritmo burbuja
	for ( i=0; i<5; i++)
	{
		for (j=0; j<4; j++) {
				//4 > 1 
			if (numeros[j] > numeros[j + 1]) {
				cambio = numeros[j]; //4
				numeros[j] = numeros[j + 1]; //1
				numeros[j + 1] = cambio;
			}
		}
	}

	for (int m = 0; m < 5; m++) {
		cout << numeros[m] << " ";
	}
	
	return 0;
}


les dejo el algoritmo por burbuja de una forma mas sencilla