No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Implementación de Bubble Sort

5/10
Recursos

Aportes 156

Preguntas 9

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Se agrega condicional que verifica si hubo cambios en la iteración anterior. Si no es así, rompe el ciclo principal:

def bubbleSort(array):
    n = len(array)
    cambios = 1
    for i in range(n): #Por estandar, los Auxiliares se definen: i, j, k...
          print("Iteracion %d",i)
          print(array)
          cambios=0
          for j in range(0,n-1-i):
            if array[j] > array[j+1]:
              array[j], array[j+1] = array[j+1], array[j]  #Se invierten los valores de las posiciones del arreglo
              cambios=1 ##Indica que hubo un intercambio de posiciones en el recorrido
          if(cambios<1): #Si no hay intercambios de posiciones (cambios no pasas a 1) se rompe el ciclo
            break

array=[190,1200,1,2,4,55,100,6,800]

bubbleSort(array)

print("El arreglo ordenado de forma ascendente: ")

for i in range(len(array)):
    print("%d", array[i]),

Agregue un booleano para optimizarlo y detenerse en caso de que el arreglo ya se encuentre ordenado antes de terminar con los cliclos:

#1. Comparaciones de elementos adyacientes
#2. Repetir hasta tener una pasada sin ningun swap


# Orders an array in a non descending order
def bubbleSort( array, showSteps = False):
    n = len(array)

    # For every element of an array
    for i in range( n ):
        changes = True #Keeps track if there are changes in the array

        # Compares 2 elementos of the array
        # Considering that in each loop, the last
        # elements are already sorted
        for j in range(0, n - i - 1):

            # If the elements are not in order, change and update trak
            if array[j] > array[ j + 1 ]:
                changes = False
                array[j], array[ j + 1 ] = array[ j + 1], array[j]
        
        # If debug mode is enable, show steps
        if showSteps:
            print("Step ", i, end = ": ")
            print(array)

        # If there were no changes in this loop, stop
        if changes:
            break


# Driver of the bubbleSort function
def main():
    array = [190, 200, 1, 2, 5, 55, 1000, 6, -80, 55]
    print("Con el arreglo", end=": ")
    print(array)

    bubbleSort(array, True)
    print("")

    print("De forma ordenada no descendente es: ")
    print(array)

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

Mi solución del reto, puse una bandera dentro del primer ciclo y si no recibe ningún cambio al pasar por el segundo ciclo for se rompe el ciclo for con un break.

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swap = False
        print(array)
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
                swap = True
        if not swap:
            break

Soy nuevo en programación y literal, me tardé un día pero lo logré ┗(^0^)┓

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

    valor = 0

    for i in range(n):
        print(array)
        valor_anterior = valor

        for j in range(0, n-i-1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
                valor += 1
        if valor_anterior == valor: break
        
        print(f'Valor = {valor}, Valor Anterior = {valor_anterior} ')



if __name__ == "__main__":
    array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]
    bubble_sort(array)


    print("-" * 100)
    print("El arreglo ordenado de forma ascendente es: ")
    for i in range(len(array)):
        print("%d"%array[i]),

La verdad tuve que ver los aportes pero bueno al final lo entendí.

#1. -Comenzar a hacer comparaciones elementos adyacentes
#2. -Repetir hasta tener una pasada completa sin ningun swap

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

    for i in range(n):
        print(array)
        cambios = False

        for j in range(0, n-i-1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
                cambios = True
        if cambios == False :
            break

array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]
bubbleSort(array)

print("El arreglo ordenado de forma Ascendente es:")
for i in range(len(array)):
    print("%d"%array[i])

Reto en JS.

function bubbleSort(arr){
  let arrLength = arr.length;
  let swapped = false;
  for (let i = 0; i < arrLength; i++) {
    swapped = false;
    for (let j = 0; j < arrLength - i; j++) {
      if ( arr[j] > arr[j+1] ){
        [ arr[j], arr[j+1] ]= [ arr[j+1], arr[j] ];
        swapped = true;
      }
    }
    if(swapped === false){
      break;
    }
  }
}
arr = [2,3,9,4,8,1,5]; 
bubbleSort(arr);
console.log(arr);

El reto seria asi:

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

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


¿Por qué con n-1 funciona igual que con n-i-1?

como no se programar en python, dejo mi codigo en c++

/* este metodo es lento por tener 2 bucles y hace muchas interacciones */
#include <iostream>
#include <ctime>
using namespace std;

int main(){
  srand(time(NULL));

  int n = 100;
  int aux, arreglo[n];

  cout<<"\tElementos Desordenados \n";
  for (int i = 0; i < n; i++){
    arreglo[i] = rand()% + 100; // rand() % (Hasta - Desde + 1) + Desde para poner un limite o solo se pone + n que sera del cero hasta n
    cout<<arreglo[i]<<" ";
  }

  for (int i = 0; i < n; i++) {
    for(int j = 0; j < n; j++){
      if(arreglo[j] > arreglo[j+1]){
        aux = arreglo[j];
        arreglo[j] = arreglo[j+1];
        arreglo[j+1] = aux;
      }
    }
  }
  cout<<"\n\n\tElementos Ordenado"<<endl;
  for(int i = 0; i < n; i++){
    cout<<arreglo[i]<<" ";
  }
  return 0;
}

Es interesante el curso sobre algoritmos, pero pienso que durante los cursos deben enseñar mas sobre las buenas practicas y como trabajar en python (en este caso) como PEP8 o por ejemplo al imprimir hacer algo como.

for i in array:
    print(i)

Inclusive asi es mucho mejor que ponerse uno a usar len, range y %d. y no simplemente hacerlo “como caiga”.

Almenos es mi punto de vista

El Reto

Acá comparto mi código; cumpliendo con el reto de parar cuando ya no hay intercambios (Swap)

# La variable (counter) me servira para determinar si se dio al menos un swap para continuar con el for Loop menos anidado.

def bubblesort(array):
    
    n = len(array)
    counter = 0 

    for i in range(n):
        print(array)
        if counter == 0:

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

            if counter != 0:
                counter = 0
            else:
                break

    return array

if __name__ == '__main__':

    array = [1, 2, 3, 4, 9, 8, 7, 6]
    print(f'El arreglo desordenado es: {array}')
    result = bubblesort(array)
    print(f'El arreglo ordenado de forma ascendente es: {result}')

Solucion

# 1.- comenzar a hacer comparaciones de elementos adyacentes
# 2.- Repetir hasta tener una pasada completa sin ningun swap

def bubbleSort(array):
    n = len(array)
    for i in range(n):
        swap = False
        print(array)
        if swap is False:
            for j in range(0, n-i-1):
                if(array[j] > array[j+1]):
                    array[j], array[j+1] = array[j+1], array[j]
                    swap = True
        if not swap:
            break     


array = [190,1200,1,2,4,55,1000,6,800]

bubbleSort(array)
print('=================================================================')
print(array)
def bubbleSort(array):
	n = len(array)

	for i in range(n):
		count=0
		print(array)
		
		for j in range(0, n-i-1):
			if array[j] > array[j+1] :
				array[j], array[j+1] = array[j+1], array[j]
				count=1
		if count == 0 :
			break				
const bubbleSort = (numbers) => {
  let temp
  let count
  for (let i = 0; i < numbers.length; i++) {
    count = 0
    for (let j = 0; j < numbers.length - 1; j++) {
      if (numbers[j] > numbers[j + 1]) {
        temp = numbers[j]
        numbers[j] = numbers[j + 1]
        numbers[j + 1] = temp
        count++
      }
    }
    if(count === 0) break
    console.log(numbers)
  }
  return numbers;
}

Mi versión en NodeJS

const desordenado = [21, 20, 4, 7, 7, 3, 6, 5, 1, 0];
console.log("Desordenado", desordenado);
const ordenado = bubbleSort(desordenado);
console.log("Ordenado", ordenado);

function bubbleSort(desordenado) {
    let swap = false; //flag que indica que hubo intercambio
    do {
        swap = false;
        for (let index = 0; index < desordenado.length - 1; index++) {
            if (desordenado[index] > desordenado[index + 1]) {
                let balde = desordenado[index];
                desordenado[index] = desordenado[index + 1];
                desordenado[index + 1] = balde;
                swap = true;
            }
        }
    } while (swap);
    return desordenado;
}


Aporte v2

def bubbleSort(array):
    n = len(array)
    
    for i in range(n):
        arr1 = array.copy()
        print(f"Arreglo: {array}")
        for j in range(0, n-i-1):
            
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
        arr2 = array.copy()
        if arr1 == arr2:
            break


array = [190,1200,1,2,4,55,1000,6,800]

bubbleSort(array)

print("El arreglo ordenado de forma Asendente es: ")
for i in range(len(array)):
    print("%d"%array[i]),

Le agregué un print en el segundo for :

def bubbleSort(array):
    n = len(array)
    
    for i in range(n):
        
        for j in range(0, n-i-1):
            print(f"Arreglo: {array}")
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]

array = [190,1200,1,2,4,55,1000,6,800]

bubbleSort(array)

print("El arreglo ordenado de forma Asendente es: ")
for i in range(len(array)):
    print("%d"%array[i]),

Mi solucion al reto:

def bubbleSort(array):
    n = len(array)
    changes = 0
    for i in range(n):
        print(array)
        print("Iteracion: ",i)
        temp=changes
        for j in range(0,n-1-i):
            if array[j]>array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]#swap
                changes+=1
        if temp==changes:
            break;
        
    print("With ", changes ," changes")
    print("The array in acendent is: ", array)

SI el valor de temp es igual al de changes es porque ya no hay más cambios

Aca dejo mi aporte con el Reto

<code> 
#1. - Comenzar a hacer comparaciones de elementos adyacentes
#2. - Repetir hasta tener una pasada completa sin ningun swap


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

    for i in range(n):
        swap = False
        print(array)
        
        if swap is False:
            for j in range(0, n-i-1):
                if(array[j] > array[j+1]):
                    array[j], array[j+1] = array[j+1], array[j]
                    swap = True

        if not swap:
            break     


array = [190,1200,1,2,4,55,1000,6,800]

bubbleSort(array)
print ("El arreglo ordenado de forma Ascendente es: ")
print(array)

Mi resultado implementado con typescipt.

const bubleSort = ( array: Array<number> ) => {
  
  const n: number = array.length;
  
  for (let i = 0; i < n; i++) {
    let next: boolean = false;
    for (let j = 0; j < n-i-1; j++) {
      if ( array[ j ] > array[ j + 1 ] ) {
        next = true;
        [ array[j], array[j+1] ] = [ array[j+1], array[j] ];
      }
    }
    if ( !next ) return array;
  }

  return array;
  
}

const arrayElements: Array<number> = [ 190, 1200, 1, 2, 4, 55, 1000, 6, 800 ];

console.log( bubleSort( arrayElements ) );

Les dejo mi implementación en Tpescript, hice dos funciones, ascendente y descendente aunque en la misma se puede tener todo con un simple parámetro ya que solo cambia un signo, pero a efectos de que esté separado y más claro así lo dejé. Espero le sirva a alguien.

( () => {

    const setDatos:number[] = [ 10, 6, 3, 4, 5, 2, 1, 12, 20, 7 ];

    const bubbleSortAsc = ( data:number[] ):number[] => {

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

                    let temp1 = data[j];
                    let temp2 = data[j+1];

                    data[j+1] = temp1;
                    data[j] = temp2;
                }
            }
        }

        return data;
    };
    
    const bubbleSortDesc = ( data:number[] ):number[] => {

        for( let i = 0; i < data.length; i++ ){
            for( let j = 0; j < data.length - i - 1; j++ ){
                if( data[j] < data[j+1] ){

                    let temp1 = data[j];
                    let temp2 = data[j+1];

                    data[j+1] = temp1;
                    data[j] = temp2;
                }
            }
        }

        return data;
    };

    console.log( bubbleSortAsc(setDatos) );
    console.log( bubbleSortDesc(setDatos) );

})();

Puntualizar que “range()” no es un comando, es una función.

Aquí está el programa que te muestra el arreglo de forma desordenada, ordenada ascendentemente y ordenada descendentemente:

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

    for i in range(n):

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

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

    for i in range(n):

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

array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]

print("Arreglo desordenado:")

for i in range(len(array)):
    print("%d" %array[i]),

bubbleSortUpward(array)

print("\n\nEl arreglo ordenado de forma ascendente es:")

for j in range(len(array)):
    print("%d" %array[j]),

print("\n\nEl arreglo ordenado de forma descendente es:")

for k in range (len(array)):
    print("%d" %array[k]),

En mi caso realicé el reto en javascript.

let array = [3584,2,50,78,-2,1056,-6658,0,51-1];

function bubbleSort(arr) {
  const length = arr.length;
  let iterations = 0

  // Loop iterating all elements
  for (let i = 0; i < length; i++) {
    let hasSwapped = false
    console.log(arr)
    console.log("iterations: ", iterations)
    // Second loop to compare adjacent elements
    for (let j = 0; j < length-i-1; j++) {
      if (arr[j] > arr[j+1]) {
        // Swapping elements
        [arr[j], arr[j+1]] = [arr[j+1], arr[j]]
        hasSwapped = true
      }
    }
    if (hasSwapped === false) {
      return arr
    }
    iterations++
  }
  return arr
}

const orderedArray = bubbleSort(array)

// console.log(array)
// console.log(orderedArray)

Pero solo era cuestion de agregar una variable que confirme si se realizaron los cambios.

Lo realice en lenguaje C.
Para el reto compare si la variable temporal que uso para el swap es (tmp != 0).

#include <stdio.h>

void	swap_printf(int *s, int n)
{
	int	i;

	i = 0;
	while (i < n)
	{
		printf("%d ", s[i]);
		i++;
	}
	printf("]");
	printf("\n");
}

int	*ft_bubbleSort(int *s, int n)
{
	int	i;
	int	j;
	int	tmp;

	i = 0;
	tmp = 1;
	while (i < n && tmp != 0)
	{
		j = 0;
		printf("i = %d [", i);
		swap_printf(s, n);
		tmp = 0;
		while (j < n -1)
		{
			if (s[j] > s[j + 1])
			{
				tmp = s[j];
				s[j] = s[j + 1];
				s[j + 1] = tmp;
			}
			j++;
		}
		i++;
	}
}

int	main(void)
{
	int		array[] = {987, 54, 542, 543, 66, 765, 1, 32, 2, 654, 87, 3, 98, 7};
	int		*res;
	size_t	n;

	n = sizeof(array) / sizeof(array[0]);
	res = ft_bubbleSort(array, n);
	return (0);
}

Ser confirma si el array o su anterior iteración son iguales, de ser así nos queda dicho que no ha habido cambios y por ende se puede romper el ciclo.

def bubbleSort(array):
    n = len(array)
    lastArrayOrder = []

    for i in range(n):

        print(array)
        lastArrayOrder = array.copy()

        for j in range(0, n-i-1):

            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]

        if lastArrayOrder == array:
            break

# array = [100, 246, 655, 23543 ,4453, 556, 96, 3, 5]
array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]
bubbleSort(array)

print("\nEl arreglo ordenado queda de la siguiente manera: ", end = " ")
for i in range(len(array)):
    print("%d"%array[i], end =" "),

PD: el end = " " en los print es solo una manera de decir que no realice un salto de linea en python 3+

1.75 jajaja me gustan las cosas rápidas!!!

Hola! Os dejo otra forma de realizar este algoritmo:

def bubble_sort(my_list):

    n = len(my_list)
    while True:
        changes = False
        for i in range(n):
            j = i + 1
            if(j) == n:
                break

            if(my_list[i] > my_list[j]):
                changes = True
                my_list[j], my_list[i] = my_list[i], my_list[j]

        if not changes:
            break

    return my_list


my_list = [190, 1200, 1, 2, 4, 55, 100, 6, 800]
order_list = bubble_sort(my_list)

print(order_list)

Ordenamiento usando método burbuja

import random

def main():
	arreglo = []

	# generando arreglo de 10 números aleatorios
	for i in range(10):
		arreglo.append(random.randint(1,99))

	print(f'El arreglo es: {arreglo}')

	# ordenando por método burbuja
	for j in range(len(arreglo)-1):
		for i in range(len(arreglo)-1):
			if arreglo[i]>arreglo[i+1]:
				arreglo[i],arreglo[i+1] = arreglo[i+1],arreglo[i]

	# arreglo ordenado
	print(f'El arreglo ordenado por método burbuja es: {arreglo}')


if __name__ == '__main__':
	main()

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado.

import random


def ordenamiento_de_burbuja(lista):
    n = len(lista)

    for i in range(n):
        for j in range(0, n - i - 1): # O(n) * O(n) = O(n * n) = O(n**2)

            if lista[j] > lista[j + 1]:
                lista[j], lista[j + 1] = lista[j + 1], lista[j]

    return lista

if __name__ == '__main__':
    tamano_de_lista = int(input('De que tamano sera la lista? '))

    lista = [random.randint(0, 100) for i in range(tamano_de_lista)]
    print(lista)

    lista_ordenada = ordenamiento_de_burbuja(lista)
    print(lista_ordenada)

Aquí dejo mi respuesta, no es mucho pero estrabajo honesto 😄

arr = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]

for i in range(len(arr)):
  if arr == sorted(arr):
    print(arr)
    break

  print(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]
#comenzar a hacer comparaciones de elementos adyacentes
# repetir hasta tener una pasada completa sin ningun swap

from abc import abstractproperty


def buble_sort(array):
    n = len(array) #detecta cuantos numero hay en el array

    for i in range(n): #recorre todos los elementos del array
        print(array)
        for j in range(0, n-i-1):
            if array[j] > array[j+1]: #se toma la posicion j y se compara con j mas uno.
                array[j], array[j+1] = array[j+1], array[j]

array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]
buble_sort(array)

print("El arreglo ordenado de forma ascendente es: ")

for i in range(len(array)): # para ir imprimiendo dinanicamente cada posicion del arreglo
    
    print("%d"%array[i]),
  

Yo plantee el reto de esta forma:

# 1) Comenzar a realizar comparaciones de elementos adyacentes.
# 2) Repetir hasta tener un recorrido completo sin hacer un swap.

def bubbleSort(array)          
    n = len(array)
    print("El arreglo inicial es: ")
    print(array)    # Muestro el arreglo inicial.
    print("")       
    swaps = 2     # Inicializo una variable que cuenta los swaps (el valor 2 es para que
                  #  se ejecute el ciclo). 

    for i in range(0, n):
        if swaps > 0:    # Si hubo un swap o más, entonces ejecute el bucle interno.
            swaps = 0        # Se hace 0 los swaps para que cuente de nuevo. 
            print("i = %s:" %i)  # Se muestra el número del recorrido actual. 

            for j in range(0, n-i-1):
                if array[j] > array[j+1]:
                    array[j], array[j+1] = array[j+1], array[j] 
                    swaps = swaps + 1       # Se incrementa en 1 los swaps.
                    print(array, end = " - j = %s \n" %j)
            print("%s swaps" %swaps)   # Se muestran los swaps que se hicieron.
        else:
            break   # Si no hubo swaps (swaps = 0), entonces finalice el bucle externo.
        print("")
    
    print("El arreglo ordenado en forma ascendente es:")
    print(array)

Se puede probar la función con los siguientes 3 arreglos de ejemplo.

# array1 = [1,2,3,4,5,6,7,8]
# array2 = [3,2,5,4,6,7,10,24,3,18,15,19]
# array3 = [5,6,13,23,19,29,21]

# bubbleSort(array1)
# bubbleSort(array2)
# bubbleSort(array3)

Quisiera aclarar algo que se menciona en el min 5:04. En realidad se resta 1 porque la caja de la izquierda del par que se va moviendo hacia la derecha debe finalizar en el penúltimo lugar de la lista. Por ejemplo, si nuestro arreglo tiene 8 elementos, entonces en el primer recorrido (cuando i=0) la j debe llegar hasta 7 (que es 8-1) porque es la última posición que puede ocupar el par dentro del arreglo (es decir, la caja de la izquierda estaría en el lugar 7 y la caja de la derecha estaría en el lugar 8). Si no se le resta 1, entonces la caja de la izquierda llega a la octava posición y la caja de la derecha quedaría en la “novena posición” la cual no existe y tendríamos un error. Hay que recordar que la función range(n) hace el recorrido desde 0 hasta n-1, es decir, no llega hasta el valor n. Espero este aporte sea de utilidad, saludos.

Mi solución al reto tanto en python como en Dart

Python

import random


def bubbleSort(array):
    n = len(array)
    changes = 0
    updated_changes = 0
    for iteration in range(n):
        for i in range(n - 1 - iteration):
            if array[i] > array[i+1]:
                array[i], array[i+1] = array[i+1], array[i]
                changes += 1
        if updated_changes == changes:
            break
        updated_changes = changes
        print(f'Iteration N° {iteration + 1}: {array} with {changes} changes')

if __name__ == "__main__":
    array = [i for i in range(10)]
    random.shuffle(array)
    print(f'Array original {array}')
    bubbleSort(array)

Dart

void main(List<String> args) {
  var array = List.generate(10, (index) => index);
  array.shuffle();
  print('Original array $array');
  bubbleSort(array);
}

void bubbleSort(List<int> array) {
  var n = array.length;
  var changes = 0;
  var updated_changes = 0;
  for (var iteration = 0; iteration < n; iteration++) {
    for (var i = 0; i < n - 1 - iteration; i++) {
      if (array[i] > array[i + 1]) {
        var temporal = array[i];
        array[i] = array[i + 1];
        array[i + 1] = temporal;
        changes++;
      }
    }
    if (updated_changes == changes) break;
    updated_changes = changes;
    print('Iteration N° ${iteration + 1}: $array with $changes changes');
  }
}

Solo pongan

elif array.sort() == array:
                break

y ya jajajaj

Para que podamos tener un BubbleSort bien implementado, necesitamos tener en cuenta que no pueden haber comparaciones repetitivas y al final se debe repasar por completo la lista sin hacer ningún Swap.

Acá dejo mis algoritmos en distintos lenguajes:

Python

def bubbleSort(array, asc=True):
    n = len(array)

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

array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]

print("El arreglo desordenado es: ")
print(array)

bubbleSort(array)
print("El arreglo ordenado de forma ascendente es: ")
print(array)

bubbleSort(array, False)
print("El arreglo ordenado de forma descendente es: ")
print(array)

C

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

#define ARRAY_SIZE 9

void bubbleSort(int *array[ARRAY_SIZE], int ascending)
{
    for(int i = 0; i < ARRAY_SIZE - 1; i++)
    {
        for(int j = 0; j < ARRAY_SIZE-i-1; j++)
        {
            int * actualValue = array[j];
            int * nextValue = array[j+1];

            if (ascending == 1) {
                if (actualValue > nextValue)
                {
                    array[j] = nextValue;
                    array[j+1] = actualValue;
                }
            }
            else
            {
                if (actualValue < nextValue)
                {
                    array[j] = nextValue;
                    array[j+1] = actualValue;
                }
            }
        }
        
        
    }
}

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

int main()
{
    int array[ARRAY_SIZE] = {190, 1200, 1, 2, 4, 55, 1000, 6, 800};
    printf("\nEl arreglo desordenado es: \n");
    printArray(array);
    
    bubbleSort(&array, 1);
    printf("\nEl arreglo ordenado de forma ascendente es: \n");
    printArray(array);

    bubbleSort(&array, 0);
    printf("\nEl arreglo ordenado de forma descendente es: \n");
    printArray(array);

    return 0;
}

JavaScript

const bubbleSort = (array, ascending = true) => {
    for(i = 0; i < array.length; i++) {
        for (j = 0; j < array.length-i-1; j++) {
            actualValue = array[j];
            nextValue = array[j+1];

            if (ascending) {
                if (array[j] > array[j+1]) {
                    array[j] = nextValue;
                    array[j+1] = actualValue;
                }
            }
            else {
                if (array[j] < array[j+1]) {
                    array[j] = nextValue;
                    array[j+1] = actualValue;
                }
            }
            
        }
    }

    return array;
}

const main = () => {
    const array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800];

    console.log("El arreglo desordenado es: \n");
    console.log(array);

    console.log("El arreglo ordenado de forma ascendente es: ");
    console.log(bubbleSort(array));

    console.log("El arreglo ordenado de forma descendente es: ");
    console.log(bubbleSort(array, false));
}

main();

PD: Cualquier sugerencia de mejora es bienvenida ♥

Mi algoritmo

def bubbleSort(array):
    n = len(array)
    for i in range(n):
        cambios = False
        for j in range(n-i-1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
                cambios = True
        if not cambios:
            break

Para los que no usan Python, aquí les dejo el como quedaría el codigo de Bubble Sort en C++.

#include <iostream>

using namespace std;

int main()
{
    int totalN = 7;
    int array[7];
    
    //El jugador ingresa numeros y estos se guardan dentro de un array
    cout << "Write 7 numbers" << endl;
    //Bucle para ir armando el array con los numeros ingresados
    for(int i = 1; i<8; i++){
        cout << "Write number " << i << ": ";
        cin >> array[i-1];
    }
    
    //Bubble Sort
    for(int i = 0; i < totalN-1 ; i--)
    {
        for(int j = totalN-1 ; j >= i+1; j--)
        {
           if (array[j-1] > array[j])
           {
               int var = array[j]; 
               array[j] = array[j-1]; 
               array[j-1]= var;
           }
        }
    }
     
    cout << endl << endl;
     
    //Imprimir la lista final ordenada
    for(int i = 0; i <= totalN-1; i++)
    {
        if(i<totalN-1)  cout << array[i] << ",";
        if(i==totalN-1)  cout << array[i];

    }
 
}




Solución en JAVA

public class BubbleSort {
    public static void main(String[] args) {
        int[] arrayNumber = {1,400,200,5,7};
        ordenBubbleSort(arrayNumber);
    }
    public static void ordenBubbleSort(int[] array) {
        int n = array.length;
        int temp = 0;
        for (int i = 0; i < n ; i++) {
            Arrays.stream(array).forEach(l -> System.out.print(l + ", "));
            System.out.println("");
            int change = 0;
            for (int j = 0; j < (n-i-1) ; j++) {
                 if (array[j+1] < array[j]) {
                     temp = array[j+1];
                     array[j+1] = array[j];
                     array[j] = temp;
                     change= 1;
                 }
            }
            if (change < 1) {
                break;
            }
        }
    }
}

En caso de alguno este interesado en saber ocmo se implementa en Kotlin, Aqui hay un articulo muy bien explicado de como hacerlo! https://medium.com/@sabbir044/algorithm-and-data-structures-in-kotlin-sorting-1-bubble-sort-b4f65b7a00ad

def bubbleSort(array): #Buena practica ponerle nombre a las variables segun lo que significan
    n = len(array) #Mientras menos inputs se pidan mejor

    for i in range(n): #Bucle recorre todos los elementos del array
        condicion = True

        print(array) #imprime todo el array
        for j in range(0, n - i - 1): #n es el total elementos del array -1 para los elementos del array

            if array[j] > array[j + 1]: #j es el numero que accedemos en arrey, j + 1 es el numero que esta al lado
                array[j], array[j+1] = array[j+1], array[j] #Esta linea cambia de posicion si se cumple el if
                condicion = False
        
        if condicion:
            break


if __name__ == "__main__":
    array = [190,1200,1,2,4,55,1000,6,800]
    bubbleSort(array)

    print("El arreglo ordenada de forma ascente es: ")

    for i in range(len(array)):
        print("%d"%array[i]),

Se pone una variable que nos indique si se realizaron cambios

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

  for i in range(n):
    print(array)
    cambio = 0 # variable que indica si hubo cambios
    for j in range(0, n-i-1):
      if array[j] > array[j+1]:
        array[j], array[j+1] = array[j+1], array[j]
        cambio += 1
    if cambio == 0: # condicional para verificacion si hubo cambios o no
      break

array = [190, 1200, 1, 2, 4, 55, 100, 6, 800]

bubbleSort(array)

print("El arreglo ordenado es: ")

for i in range(len(array)):
  print("%d"%array[i]),```
import random

ar = [random.randint(0,1000) for _ in range(100)]

def bubbleSort(ar):
    for i in range(0,len(ar)-1):
        for j in range(0,len(ar)-1):
            if(ar[j]!=ar[j+1]):
                if(ar[j]>ar[j+1]):
                    temp = ar[j]
                    ar[j]=ar[j+1]
                    ar[j+1]=temp
    return ar
print(bubbleSort(ar))

uff buenisimo!!!

let arr = [3,1,2,5,8,10,9,6];

const bubbleSort = (arr) => {
    let size = arr.length - 1;
    let aux = 0;
    let iter = 0;
    for(let i = 0; i < size; i++) {
        for(let j = 0; j < size - i; j++ ){
            if(arr[j] > arr[j+1]){
                aux = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = aux;
                iter++;
            }
            console.log(arr + ` pasada ${j}`);
        }       
        if(iter === 0){
            break;
        }
        iter = 0;
    } 
}

bubbleSort(arr);

Aqui esta el reto en Java, imprime el array cada vez que se hace un cambio:

public class MyClass {
    public static void main(String args[]) {
      int[] arr = {190, 1200, 1, 2, 4, 55, 1000, 6, 800};
      
      for(int i = 0; i < arr.length; i++){
          for(int j = 0; j < arr.length-i-1; j++){
                if(arr[j] > arr[j+1]){
                    int aux = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j]  = aux;
                    for(int k = 0; k < arr.length; k++){
                        System.out.print(arr[k]+ " ");
                    }
                    System.out.println(" ");
                } 
            }
        }
    }
}

Codigo en Java.
Solo es cuestion de Mandarlo llamar de igual manera e imprimir si asi se desea.

public static void bubbleS(int array[]) {
        int aux, n = array.length; //Tamaño del Arreglo.

        for (int i = 0; i < n; i++) { //For que nos ayudara a recorrer todo el Array.
            for (int j = 0; j < (n - i - 1); j++) { //For que Compara a los valores adyacentes

                if (array[j] > array[j + 1]) { // Comparacion de numero mayor que el de a lado
                    aux = array[j]; // Variable auxiliar para guardar el valor anterior de la posicion j
                    array[j] = array[j + 1]; //Asignacion del valor mas pequeño en la posicion correcta
                    array[j + 1] = aux; // Asignacion del valor Mayor en la posicion correcta
                }
            }
        }
        
    }

Main para llamar al metodo:

public static void main(String args[]) {
        //Metodo de Ordenamiento: BubbleSort de forma Ascendente.
        
        // Declaramos un Array.
        
        int array[] ={23,1,6543,12,12,76,23,2,8765,3};
        
        System.out.println("El array Original es:");
        for(int i:array){
            System.out.print(i+" ");
        }
        
        bubbleS(array);
        
        System.out.println("\n-----------------------------------------------------");
        System.out.println("El array ordenado es:");
        for(int i: array){
            System.out.print(i+" ");
        }
        System.out.println("");
    }

Solo puse que contara las veces que hizo algún cambio

def bubble_sort(array):
    size = len(array) - 1
    for j in range(size):
        for i in range(size):
            current = array[i]
            next_ = array[i + 1]
            if current > next_:
                array[i], array[i + 1] = next_, current
        size -= 1

    return array



print(bubble_sort([2, 2, 5, 4, 7]))
print(bubble_sort([3, 1, 4, 4, 7, 8, 0, 9]))
print(bubble_sort([10, 3, 1, 4, 4, 7, 8, 0, 9]))

python buble_sort.py 
[2, 2, 4, 5, 7]
[0, 1, 3, 4, 4, 7, 8, 9]
[0, 1, 3, 4, 4, 7, 8, 9, 10]

Codigo en Java imprimiendo cada ciclo de ordenamiento

import java.util.Arrays;

public class BubbleSort {
    static void bubbleSort(int[] numeros){
        int n= numeros.length;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n-i-1; j++) {
                if(numeros[j]>numeros[j+1]){
                    int temp = numeros[j];
                    numeros[j]=numeros[j+1];
                    numeros[j+1]=temp;
                }
                System.out.println("El array resultante es: " + Arrays.toString(numeros));
            }
        }
    }

    public static void main(String[] args) {
        int[] numeros = {190, 1200, 1, 2, 4, 55, 1000, 6, 800};
        bubbleSort(numeros);
        System.out.println("El arreglo ordenado es: " + Arrays.toString(numeros));

    }
}

Que opinan o como se sienten mejor nombrando variables: camelCase, under_score(snake_case), PascalCase o kebab-case???

Código organizado y con comentarios para que la comunidad los entienda de una manera mas practica. (Reto complido) 😃

# 1. Comparaciones de elementos subyacentes
# 2. Repetir hasta tener una pasada completa sin ningun Suap

def bubbleSort(array, ):
    n = len(array)
    for i in range(n):
        #Declaramos los cambios en False para iniciar
        changes = False
        #Imprimimos el array con los cambios 
        print(array)

        for j in range(0, n-i-1):

            if array[j] > array[j + 1]:
                #Cambiamos los valores de lugar
                array[j], array[j + 1] = array[j + 1], array[j]
                #Asignamos cambios a True para decir que si se generaron cambios
                changes = True
            else:
                #Asignamos cambios a False rompiendo el bucle diciendo que no hay mas cambios por hacer
                changes = False
        
        #Si al volver a hacer el bucle se detecta que no hubieron cambios, se rompe el ciclo 
        if changes == False:

            break




def main():
    #Creamos el array para pasar los datos
    array = [190, 200, 1, 2, 5, 55, 1000, 6, -80, 55]

    #Llamamos al metodo para organizar los datos
    bubbleSort(array)
    # Imprimimos los datos ordenados por pantalla 
    for i in range(len(array)):
        print("%d"%array[i]),


if __name__ == "__main__":
    main()

Solución reto

# Bubble Sort Algoritmo

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

    for i in range(n):
        stop = True
        print(array)
        for j in range(0, n-i-1):
            if array[j] > array[j+1]:
                print(f'Swap: [{array[j]}][{array[j+1]}] => [{array[j+1]}][{array[j]}]')
                array[j], array[j+1] = array[j+1], array[j]
                stop = False

                if stop == True:
                    break

        print('-----')

array = [190, 120, 840, 1, 6, 845]
bubbleSort(array)

Lo mismo pero Descendente y usando while en el segundo Loop. Disculpen que las variables no sean más descriptivas, ya tiene rato que lo hice ja

def simpleSort(arr):

    n = len(arr)

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

Reto con JS, una buena práctica tambiés es que debemos saber si el arreglo que recibimos tiene longitud. E n este caso el ciclo solo se realizará si el primer elemento es mayor que el elemento en la posición que siguiente.

function bubbleSort(arr) {
  if (arr.length === 0) {
    return arr;
  } else {
    let i, j;
    for (i = 0; i < arr.length - 1; i++) {
      console.log(arr);
      for (j = 0; j < arr.length - 1; j++) {
        if (arr[j] > arr[j + 1]) {
          let temp = arr[j];
          arr[j] = arr[j + 1];
          arr[j + 1] = temp;
        }
      }
    }
  }
  return arr;
}

const numbers2 = new Array(10)
  .fill(0)
  .map(() => Math.floor(Math.random() * 11));
console.log(numbers2);
console.log(bubbleSort(numbers2));```

Me gustaría recibir feedback respecto a esta variante que me funcionó muy bien pero usa un solo ciclo y una bandera que recorre el array una vez sin evidenciar números en posición equivocada y rompe la ejecución. Está en java.

public static int[] ordenar(int[] numbers, int type){
    Boolean ordered = false;
    int flag = 0;
    int swappedNumber = 0;
    while (ordered == false){
        flag = 1;
        for (int i = 0; i < numbers.length-1; i++) {
          if (type == 1){
              if(numbers[i]>numbers[i+1]){
                  swappedNumber = numbers[i];
                  numbers[i]=numbers[i+1];
                  numbers[i+1]=swappedNumber;
                  flag = 0;
              }
          } else{
              if(numbers[i]<numbers[i+1]){
                  swappedNumber = numbers[i];
                  numbers[i]=numbers[i+1];
                  numbers[i+1]=swappedNumber;
                  flag = 0;
              }
          }

        }
        if (flag == 1){
            ordered = true;
        }
    }
    return numbers;
}

no entendía muy bien el código asi que imprimí cada paso para ver como funcionaba y creo que ya me doy una idea
![](

En Java…

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] lista = {9, 8, 7, 6};
        System.out.println("Array de números sin ordenar:");
        System.out.println(Arrays.toString(lista));
        System.out.println("Número de elementos: " + lista.length);
        System.out.println("///////////");
        //variable para contar los intercambios.
        int cuentaintercambios = 0;
        //Usamos un bucle anidado, saldra cuando este ordenado el array.
        //Si hay intercambios, es porque no esta ordenado.
        for (boolean ordenado = false; !ordenado; ) {
            for (int i = 0; i < lista.length - 1; i++) {
                if (lista[i] > lista[i + 1]) {
                    //Intercambiamos valores
                    int variableauxiliar = lista[i];
                    lista[i] = lista[i + 1];
                    lista[i + 1] = variableauxiliar;
                    //Indicamos que hay un cambio.
                    cuentaintercambios++;
                    System.out.println("Números que se mueven: " + variableauxiliar + "-" + lista[i]);
                    System.out.println(Arrays.toString(lista));
                }
            }
            //Si no hay intercambios, es que esta ordenado.
            if (cuentaintercambios == 0) {
                ordenado = true;
            }
            //Inicializamos la variable de nuevo para que empiece a contar de nuevo.
            cuentaintercambios = 0;
        }
        System.out.println("///////////");
        System.out.println("Array de números ordenado:");
        System.out.println(Arrays.toString(lista));
    }
}

Mi implementación en java.

import java.util.Arrays;
import java.util.Random;
import java.util.function.Predicate;

public class BubbleSort8 {

    public void bubbleSort(final int array[], final Predicate<Integer> sortType) {
        final int n = array.length;
        boolean sorted = false;
        int temp;
        print("Size n: %d%n%n", n);

        // Subtract 1 to avoid traversing the first element cause it is already ordered.
        // Break it to avoid useless loop if it's ordered
        for (int i = 0; i < n - 1 && !sorted; i++) {
            print("Iteration %d input %s%n", i + 1, Arrays.toString(array));
            sorted = true;
            // One is subtracted to be able to compare the penultimate and the last.
            // [j] > [j + 1].
            for (int j = 0; j < n - i - 1; j++) {
                final boolean swaps = sortType.test(j);
                print("Comparing array[%d]=%s, array[%d]=%s, swaps=%b%n", j, array[j], j + 1, array[j + 1], swaps);

                if (swaps) {
                    // swap arr[j+1] and arr[i]
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    sorted = false;
                }
            }

            print("Iteration %d ouput %s%n", i + 1, Arrays.toString(array));
            print("%s%n%n", "-".repeat(46)); // Java 11 only
        }
    }

    private void print(final String template, final Object... values) {
        System.out.printf(template, values);
    }

    public static void main(final String args[]) {
        final int n = 6;
        final int randomNumbers[] = new Random().ints(n, 0, 100).toArray();
        final Predicate<Integer> orderAsc = j -> randomNumbers[j] > randomNumbers[j + 1];

        final BubbleSort8 bubbleSort = new BubbleSort8();
        bubbleSort.bubbleSort(randomNumbers, orderAsc);
    }
}

He aquí una solución para el problema con JS. También la implementación para romper el ciclo en caso de concluir.
.

me tomo algo de tiempo en pensar una solucion para romper el codigo en el momento exacto cuando ya no hay mas numero a ordenar pero lo halle
![](
lo que hice fue igualar el numero de veces en la que la condicion de array[j] > array [j + 1] no se ejecutara con la dimencion del array y voala se hizo la luz XD

def bubbleSort(array):
	n = len(array)
	romper = False

	for i in range(n):
		elses = 0
		print(array)
		for j in range(0, n - i -1):
			if array[j] > array[j+1] :
				array[j], array[j+1] = array[j+1], array[j]
			else:
				elses = elses + 1
			if  elses == (n - i - 1):
				romper = True
		if romper:
			break```

Mi solución:

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

    for i in range(n):  
        print(values)  
        is_sorted = True
        for j in range(n - i - 1):
            if values[j] > values[j + 1]:
                values[j], values[j + 1] = values[j + 1], values[j]
                is_sorted = False

        if is_sorted:
            break
    
    return values

if __name__ == "__main__":
    data_set = [5, 5, 6, 654, -645, 654, 4, 3, -2, 7, 65, 2, 8, 0, -9, 43, 91, 745, -7, 0, 34, 45, 98, 923, -234, 97237, 777, 666, 243, -954, 23, 1]
    
    sorted_data_set = bubble_sort(data_set)
    print(sorted_data_set)

under_score es el estándar en python. Podemos verlo en el PEP.. Recordemos que es una recomendación, un estándar mas no una regla.

Aquí el reto, si hay algún error estoy para recibir feedback

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

    for i in range(n):
        print(array)
        count = 0;

        for j in range(0, n-i-1):
            if array[j] > array[j+1] :
                array[j], array[j+1] = array[j+1], array[j] # Intercambio
            else:
                count = count + 1

        if count == n-i-1:
            break

array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]

bubbleSort(array)
print('El arreglo ordenado de forma Ascendente es:')
for i in range(len(array)):
    print("%d"%array[i]),
import java.util.Arrays;
import java.util.Comparator;

/**
 * @author Edinson E. Padrón Urdaneta - https://platzi.com/@EPadronU23/
 */
public class BubleSort {

  public static void main(String... argv) {
    final Integer[] array1 = {5, 3, 7, 4, 2, 9, 8, 1, 6, 0};

    final Integer[] array2 = {5, 3, 7, 4, 2, 9, 8, 1, 6, 0};

    System.out.println(String.format(":: Ascending ::"));

    System.out.println(String.format("Before sorting:\t%s", Arrays.toString(array1)));

    sort(array1, (a, b) -> Integer.compare(a, b));

    System.out.println(String.format("After sorting\t%s", Arrays.toString(array1)));

    System.out.println("====================");

    System.out.println(String.format(":: Descending ::"));

    System.out.println(String.format("Before sorting:\t%s", Arrays.toString(array2)));

    sort(array2, (a, b) -> -Integer.compare(a, b));

    System.out.println(String.format("After sorting\t%s", Arrays.toString(array2)));
  }

  // For more about the Comparator interface:
  // https://docs.oracle.com/javase/8/docs/api/index.html?java/util/Comparator.html
  public static <T> void sort(T[] array, Comparator<T> comparator) {
    // Tiny optimization - If we didn't swap values in an entire run, that
    // means the array is sorted already and we shouldn't continue
    boolean wasSwapPerformed = true;

    // Use to swap the values in the array
    T aux = null;

    while (wasSwapPerformed) {
      wasSwapPerformed = false;

      for (int i = 0; i < array.length - 1; i++) {
        // If array[i] > array[i + 1] according to `comparator`
        if (comparator.compare(array[i], array[i + 1]) > 0) { // Then swap
          aux = array[i];
          array[i] = array[i + 1];
          array[i + 1] = aux;

          wasSwapPerformed = true;
        }
      }
    }
  }
}
:: Ascending ::
Before sorting: [5, 3, 7, 4, 2, 9, 8, 1, 6, 0]
After sorting   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
====================
:: Descending ::
Before sorting: [5, 3, 7, 4, 2, 9, 8, 1, 6, 0]
After sorting   [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Desafío cumplido

def bubbleSortAsc(lista):
    comparaciones = False
    for i in range(len(lista)-1):
        if comparaciones:
            break
        else:
            comparaciones = True
            for indice in range(len(lista)-i-1):
                if lista[indice] > lista[indice+1]:
                    aux = lista[indice+1]
                    lista[indice+1] = lista[indice]
                    lista[indice] = aux
                    comparaciones = False

def bubbleSortDes(lista):
    comparaciones = False
    for i in range(len(lista)-1):
        if comparaciones:
            break
        else:
            comparaciones = True
            for indice in range(len(lista)-i-1):
                if lista[indice] < lista[indice+1]:
                    aux = lista[indice]
                    lista[indice] = lista[indice+1]
                    lista[indice+1] = aux
                    comparaciones = False
            


def run():
    lista = [1,15,4,3,9,10,2,5,20,14,7]
    bubbleSortAsc(lista)
    print(lista)
    bubbleSortDes(lista)
    print(lista)

if __name__ == '__main__':
    run()
def bubbleSortPrint(array):
        n = len(array)
        
        for i in range(n):
            print([array])
            comparaciones = True

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

Esto va en dart.

void main() {
  
  //Asigno mi array a la siguiente variable
  var array = [190,1200,1,2,4,55,1000,6,800];
  
  //Capturo el valor de la longitud de mi array
  int n = array.length;
  print('El numero de elementos de mi array es: $n');
  
  //For para recorrer a mi arreglo
  for(int i=0; i<n; i++) {
    print(array);
    bool swaped = false;
     //print(i);
     //Bucle para comparar los elementos adyacentes de mi arreglo
    for(int j = i+1; j<n; j++){
      //print(j);
     //Cambio de elementos adyacentes con una condicion
      if(array[i] > array[j]) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
        swaped = true;
      }
    }
    if(!swaped)
      break;
  }
  
  //Print del resultado
  print('El arreglo ordenado de forma Ascendente es: ');
  for(int i=0; i<n; i++)
    print(array[i]);
  
}

Este es mi codifgo creo que con format es mas sencillo y enendible imprimir el array

def bubbleSort(array):
    length = len(array)
    
    for i in range(length):
        stop = 0
        print("The array is {}".format(array))

        for j in range(0, length-i-1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
                stop = 1
            
        if stop == 0:
            print("We break the array is {}".format(array))
            break
        



array = [190,1200, 1 -234, 3, 58, 1000, 78, 890]
bubbleSort(array)

print("Array  ordered in ascendent is: {}".format(array))

Adjunto codigo de reto:

def bubbleSort(array):
    n = len(array)
    final = 0

    for i in range(n):
        if final == 1:
            break
        else:
            print(array)
            for j in range(0, n-i-1):
                final = 1
                if array[j] > array[j+1]:
                    array[j], array[j+1] = array[j+1], array[j]
                    final = 0


array = [190, 1200, 52, 8645, 5421, 649, 9632, 632]
bubbleSort(array)

print("El arreglo ordenado de forma ascendente es: ")
for i in range(len(array)):
    print("%d" %array[i]),

No entiendo para que imprime el arreglo con un ciclo adicional, no es necesario con solo colocar print(array) imprime el arreglo ordenado. Es de las cosas que python nos permite, si fuera en c o c++ si hay hacerlo pero en python no, es la magia de un lenguaje interpretado

<

def bubleSort(array):
    n = len(array)
    cambio = 1

    for i in range(n):

        cambio = 0
        for j in range(0, n - i - 1):

            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
                cambio = 1
                print(array)
        if(cambio<1):
            break
        print('---------------'*3)


array = [1907, 9, 12005, 1, 35000, 5, 200, 7, 2000, 1]
bubleSort(array)

print('El arreglo ordenado de forma Ascendente es: ')
print(array),

>

Implementación en Java

private static void bubbleSort(Integer[] array) {
		if(array.length > 1) {
			boolean swap = false;
			for(int i = 0; i < array.length -1; i++) {
				swap = false;
				for(int j = 0; j < (array.length - i - 1); j++) {
					if(array[j] > array[j+1]) {
						swap = true;
						swap(array,j,j+1);
					}
				}
				if(!swap) {
					break;
				}
			}		
		}
	}
	
	private static void swap(Integer[] array, int origin, int destinity) {
		int tempValue = array[origin];
		array[origin] = array[destinity];
		array[destinity] = tempValue;
	}
}
<def bubbleSort(lista):
    n = len(lista)

    for i in range(n):
        print(lista)
        for j in range(0, n-i-1):
            if lista[j] > lista[j+1]:
                lista[j], lista[j+1] = lista[j+1], lista[j]
        if i > j:
            break



lista = [190,1200,1,2,4,55,1000,6,100]

bubbleSort(lista)
print("Esta es la lista ordenada:")
for i in range(len(lista)):
    print("%d"%lista[i])>
def bubble(arr):
  n= len(arr)
  for i in range(n):
    sw = False
    print(arr)
    if sw == False:
      for j in range(0,n-i-1):
        if arr[j] > arr[j+1]:
          arr[j],arr[j+1]=arr[j+1],arr[j]
          sw = True
    if not sw:
      break
  
array = [190,1200,1,2,4,55,1000,6,800]

bubble(array)
print(array)

Incluyendo el reto antes de que el profe lo hiciera más fácil, jajaj

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

    for i in range(n):
    
        for j in range(0, n-i-1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
        
        for k in range(n):
            print("%d"%array[k]),

        print("\n")    

array = [190, 1200, 1, 2, 4, 55, 1000, 6, 0, -8]
bubbleSort(array)
print("El arreglo ordenado de forma ascendente es:")
for i in range(len(array)):
    print("%d"%array[i]),

Con el segundo reto:

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

    for i in range(n):
        k = False
        print(array)
        for j in range(0, n-i-1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
                k = True
        
        if k == False:
            break
            

array = [1, 2, 3, 4, 5, 6, 7, 8, 11, 10]
bubbleSort(array)
print("El arreglo ordenado de forma ascendente es:")
for i in range(len(array)):
    print("%d"%array[i]),
defbubbleSort(array):
	n = len(array)

	for i in range(n):
		count=0
		print(array)
		
		for j in range(0, n-i-1):
			if array[j] > array[j+1] :
				array[j], array[j+1] = array[j+1], array[j]
				count=1
		if count == 0 :
			break```

Para el segundo reto utilice un booleano

Este booleano ‘ordenado’ cambiara de valor a FALSE cada vez que se haga un SWAP y cuando se hago un swap entonces tendra un valor de TRUE

Imprimiendo el valor de ‘ordenado en cada iteracion’ del recorrido del array, el booleano se evalua antes de que se entre al segundo ciclo for

imprimiendo solo lo necesario

codigo



def bubbleSort(array):

    n = len(array)


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

        if i > j:
            break
        

    
array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]

bubbleSort(array)

print('El arreglo ordenado de forma Ascendetees:')


for i in range(len(array)):
    print('%d'%array[i]),

A seguir aprendiendo

def bubbleSort(array):
	n=len(array)
	print("Elementos n:",n)	
	for i in range(n):  #recorre los elementos del array
		#print(array," i:",i)
		print(array)
		contador=0	
		for j in range(0,n-i-1): 
			#print("rango:0,",n-i-1,"j:",j)			
			if array[j]>array[j+1]:
				array[j],array[j+1]=array[j+1],array[j]	
				contador=contador+1			
			#print(array[j],array[j+1])
		if contador==0:
			break #si no detecta que hubo ordenamiento sale
			
array=[1,4,2,3]
bubbleSort(array)
print("Arreglo ordenado: ")
for i in range(len(array)):
	print("%d"%array[i])
<def bubbleSort(array):
    n = len(array)

    for i in range(n):
        for j in range(0, n-i-1):
            print(array), #Imprimo el array a medida que se va ordenando en el segundo ciclo
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]



array = [190, 1200, 1, 2, 4, 55, 100, 6, 800]

bubbleSort(array)
print("El arreglo  ordenado de forma ascendente es: ")
for i in range(len(array)):
    print("%d"%array[i]),
>

Que gran diferencia esta explicación a la del curso anterior! 😃

Versión en JavaScript

const dataSet = [1997, -2, 4, 3, 0, 100, 12, 20, 123, -6, -8, 10]

const bubbleSort = arr => {
    let n = arr.length

    for(let i = 0; i < n; i++){
        console.log("Ciclo: " + i)
        for(let j = 0; j < n-i; j++){
            if(arr[j] > arr[j+1]){
                swap(arr, j, j+1)
                // console.log("Cambio entre " + arr[j] +  " y " +  arr[j+1])
            }
        }
        console.log(arr);
    }
    return arr
}

const swap = (arr, n1, n2) => {
    let temp = arr[n1]
    arr[n1] = arr[n2];
    arr[n2] = temp;
}

console.log(bubbleSort(dataSet))
#1. Comenzar hacer comparaciones de elementos adyacentes
#2. Repetir hasta tener una pasada completa sin ningun swap

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

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

array = [1 ,4, 2, 1000, 56, 45, 78, 28, 36, 98, 123, 56]
bubbleSort(array)

print("EL orden correcto es:")
for i in range(len(array)):
    print ("%d"%array[i]),```

En Java 😁

def bubble_sort(array):
    n = len(array)
    for i in range(n):
        print(array)
        for j in range(n - i - 1):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
            else:
                continue

    print(array)

    return None


if __name__ == '__main__':
    array = [2, 5, 4, 2, 7]
    bubble_sort(array)

Excelente clase!

Adjunto mi algoritmo con unas modificaciones:

import random
import time

def bubblesort(list_size):

    numbers = []
    iteration_i= 0
    iteration_j = 0
    start = time.time()
    #numbers = [random.randint(0, 100) for i in range(list_size)]
    numbers = list(range(list_size)) 
    random.shuffle(numbers)

    for i in range (len(numbers)-1): # O(n)
        iteration_i += 1
        for j in range (len(numbers)-i-1): # O(n)
            iteration_j += 1
            if numbers[j] > numbers[j+1]:
                numbers[j], numbers[j+1] = numbers[j+1], numbers[j]

    final = time.time()
    finaltime = final - start

    #O(n)*O(n) = O(n**2)
    return (numbers, iteration_i, iteration_j, finaltime)

if __name__ == "__main__":
    
    list_size = int(input('enter the size of the list: '))
    my_list = bubblesort(list_size)
    print(my_list)

Tambien se puede imprimir el array sin iterarlo

Pensé que se querían todos los cambios que hubo en cada iteración.

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

    for i in range(n):
        for j in range(0, n-i-1):
            if array[j] > array [j+1]:
                array[j], array[j+1] = array[j+1], array[j]
                print("Cambió",array[j], "por",array[j+1])
            else:
                print("No hubo cambio")
          

array = [190, 1200, 1, 2, 4, 55, 1000, 6, 800]
bubbleSort(array)

print ("El arreglo ordenado de fomra ascendente es:")
for i in range(len(array)):
    print("%d"%array[i]),```