Cursos Empresas Blog Live Conf Eventos Precios

0:0013:45

Recursos

Resumen

¿Cómo preparar tu implementación de algoritmo?

Cuando trabajamos en un algoritmo es crucial tener claridad y estructura. Iniciar con una pequeña sección de comentarios ayuda a mantener el enfoque y a recordar el objetivo del código. Es una buena práctica que se debe seguir para guiar el desarrollo de cualquier programa.

¿Cómo definir nuestra función en Python?

Estamos por implementar una función de ordenamiento. La buena práctica es darle un nombre significativo. En Python se suele usar la convención de nombres en camelCase. Por ejemplo, bubbleSort. Así comenzamos con minúsculas y cada nueva palabra la iniciamos con mayúscula. Una vez tenemos el nombre, el siguiente paso es definir los parámetros necesarios para la función. En este caso, necesitaremos un arreglo sobre el que trabajar.

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

¿Cómo recorrer los elementos del arreglo?

Utilizaremos dos bucles for. El primero recorre todos los elementos del arreglo. El segundo bucle comparará elementos adyacentes para determinar si deben intercambiarse.

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

El uso de len(arr) nos evita pedir al usuario especificar cuántos elementos tiene el arreglo, haciendo el código más flexible y autónomo.

¿Cómo realizar el intercambio de elementos?

Al identificar que un elemento es mayor que su adyacente, realizamos el intercambio con un simple truco que nos permite hacerlo en una sola línea en Python.

arr[j], arr[j+1] = arr[j+1], arr[j]

Este sencillo paso culmina el ordenamiento de dos elementos adyacentes si se encuentran fuera de lugar.

¿Cómo ejecutar y verificar la función?

Para probar la función, creamos un arreglo con valores aleatorios y llamamos a la función pasando este arreglo como argumento. Después, imprimimos el arreglo ordenado para verificar que el algoritmo funciona correctamente.

arr = [19, 12, 1, 2, 3, 55, 1000, 800]
bubbleSort(arr)
print("El arreglo ordenado de forma ascendente es:")
print(arr)

Desafíos para mejorar el algoritmo

El ejercicio propuesto es detectar si no se realizaron intercambios en un ciclo completo para detener la función anticipadamente. Esto mejora la eficiencia del algoritmo al dejar de comparar cuando ya todos los elementos están en orden.

Reto adicional

Implementa una lógica que rompa el bucle si no hay intercambios durante un recorrido, para un mejor rendimiento del algoritmo.

Recuerda, mejorar y optimizar los algoritmos es una parte esencial del aprendizaje. ¡Continúa practicando!

Ordenamiento de Burbuja en Python: Implementación y Ejercicio Práctico

Curso de Introducción a los Algoritmos de Ordenamiento

Clase 5 / 10

Ver clases

Ordenamiento de Burbuja en Python: Implementación y Ejercicio Práctico

Curso de Introducción a los Algoritmos de Ordenamiento

Clase 5 de 10

Clase 5 / 10

Ordenamiento de Burbuja en Python: Implementación y Ejercicio Práctico

Curso de Introducción a los Algoritmos de Ordenamiento

Clase 5 / 10

Ver clases

Comentarios (193)193 comentarios

Hiram Rodriguez Gomez

Hace 7 años

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

Ramón Ruiz

Hace 6 años

Gracias no entedía como hacer el reto, pero con tu código ya me quedo claro.

Sergio Brandon De Lucio Chavero

Gracias por el código, no suelo hacer código en Python, pero ya lo estoy controlando mejor .

Carlos Nassif Trejo Garcia

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

Yiyo Castillo

Buen aporte

DARWIN JUAN CARLOS CATUNTA GARCIA

Nice

camilo fernando jiménez figueroa

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

marco antonio

vaya tu solucion es muy elegante en comparacion a la mia que fue muy brusca XD

jajajaja, gracias

Sergio Daniel Castañeda Pérez

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

Elsa Portilla Hernandez

Super bien resuelto! felicidades!

Excelente

Juan Pablo Perez

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

Andrés Campuzano Garzón

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

En ambos casos va a funcionar la diferencia es que si usas n-i-1 estarás iterando menos veces en el segundo for, si pones n-1 siempre estarás iterando hasta el penúltimo elemento,es decir, j siempre llega a tener el valor n-1 y siempre compara hasta con i hasta que i = n, pero eso no es necesario ya que las ultimas posiciones son las primeras en ordenarse (en cada iteracion siempre el elemento mayor quedara al final) por lo que ya no es necesario iterar hasta el final, en cambio las primeras posiciones son las que aun faltan datos por ordenar, por ello no tiene sentido que el segundo for siempre llegue hasta n-1, con n-i-1 es mas eficiente. Aunque en ambas situaciones la complejidad sigue siendo O(n^2).

Oliver Jesus Tuesta Yoplac

al poner (n-i-1) se hacen menos recorridos en el segundo for, porque por cada recorrido del array el valor más alto se pone en el último lugar, y para el siguiente recorrido ya no es necesario pocesarlo otra vez ese último dato del array porque ya está bien ubicado

Elisa Zamarron Muñoz

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

Edwin Jesset Barrientos Gonzales

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]

Jose Miguel Angel Presa Hernandez

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

William Wilfredo Moran Torres

PORQUE EL -i en el for de j

Miguel Torres

Hola, @wlm.morant. 🤓

Eso es porque el límite del for interno va dejando fuera de las comparaciones a los últimos números de la lista porque de acuerdo al algoritmo va colocando hasta el final los números de mayor tamaño. Entonces no tendría sentido seguirlos comparando si son los mayores y ya están en su posición correcta.

Jorge Cruz Perez

Por esta razon: la primer pasada si notas siempre va a traer el numero mas grande al final, si es ascendente. en la segunda pasada trae el segundo mas grande y solo se recorre n-1 veces, la tercer pasada trae el tercero mas grande y solo se recorre n-2 veces, y asi hasta el final,

Alejandro Favila

Hola Ricardo, ¿Que plugin instalaste en visual code para que te salga la flecha que representa la tabulacion?

Juan Castro

Profesor

Eso se llama white space rendering. Aquí encuentras más información: https://stackoverflow.com/questions/30140595/show-whitespace-characters-in-visual-studio-code.

Nicolay Alexander Corrales Vargas

Ya no esta esa extensión, o saben si aparece con otro nombre? Gracias

David Esteban Solorzano Taborda

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

Carlos Naveda

El Reto

Christian García Valencia

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

Creck Brayan Mauri Pastor Paredes

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)

Jackeline Maria Hernandez Maurera

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

Gilberto Posso

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

Emiliano Van den Heuvel

Hace 3 meses

Agregamos una varialbe que cuente la cantidad de cambios que realizo en cada iteracion. si no realiza ningun cambio la variable continua en 0 y rompe el ciclo for

Roberto Carlos Rivera Ramirez

Hace 5 meses•editado

Esta es mi versión del código pero esta echa con C++ espero les sirva, OJO le hacen falta algunos comentarios para que sea mas clara.

#include <iostream>

#include <utility>

using namespace std;

//plantillas

template <typename T > //template se usara como una funsión abtracta para poderla ocupar en diferntes tipos de datos

void boubbleSort (T arr [],int n){//n es el tamaño del arreglo ya que en c++ se pasa solo el primer puntero del arreglo

for(int i=0; i < n-1 ; i ++){

cout << "El estado del arreglo es: \n";

cout << arr[i] << " ";

}

cout << endl;

for (int j=0; j < n-i-1; j++){//podemos quitar el -i pero asi ya no pasamos por elementods ya ordenados

if(arr[j] > arr[j+1]){

swap(arr[j], arr[j+1]);// en esta linea intercambialos los elementos del arreglo de lugar

int main(){

int arreglo[10] = {14,22,5,8,9,14,15,1,74,2};

int tam = sizeof(arreglo) / sizeof(arreglo[0]);

cout << "El arreglo original es: \n";

for (int i=0; i < tam-1;i++ ){

cout << arreglo[i] << " ";

devuelve el del dato ovariable ne bytes, mas el numero de bytes del array

si dividimos el array entre el tamañó de sus elementos podemos obtener el total de elementos

boubbleSort(arreglo, tam);

cout << "El nuevo orden del arreglo es: \n";

for (int i = 0; i < tam; i++){

return 0;

Johan Guzman Gil

Hace 5 años

¿Me gustaría saber más sobre los auxiliares, alguien sabe donde puedo obtener más información?

Recursos

Resumen

Ordenamiento de Burbuja en Python: Implementación y Ejercicio Práctico

Ordenamiento de Burbuja en Python: Implementación y Ejercicio Práctico

Ordenamiento de Burbuja en Python: Implementación y Ejercicio Práctico

Progreso del curso

Introducción

Bubble Sort

Selection Sort

Cierre

Ordenamiento de Burbuja en Python: Implementación y Ejercicio Práctico

Ordenamiento de Burbuja en Python: Implementación y Ejercicio Práctico

Recursos

Resumen

¿Cómo preparar tu implementación de algoritmo?

¿Cómo definir nuestra función en Python?

¿Cómo recorrer los elementos del arreglo?

¿Cómo realizar el intercambio de elementos?

¿Cómo ejecutar y verificar la función?

Desafíos para mejorar el algoritmo

Reto adicional

Comentarios

Recursos

Resumen

¿Cómo preparar tu implementación de algoritmo?

¿Cómo definir nuestra función en Python?

¿Cómo recorrer los elementos del arreglo?

¿Cómo realizar el intercambio de elementos?

¿Cómo ejecutar y verificar la función?

Desafíos para mejorar el algoritmo

Reto adicional

Comentarios