🖐 Visita nuestro proyecto y apoyanos con una ✨
El ordenamiento por burbuja (Bubble Sort) es un algoritmo de ordenamiento elemental que organiza los elementos de una lista comparando de manera repetitiva pares adyacentes y realizando intercambios si están en el orden incorrecto. Su nombre se debe a la forma en que los elementos más grandes van “flotando” hacia el final de la lista, como si fueran burbujas que ascienden a la superficie. Tranquilo, si ahora no te hace mucho sentido, más adelante lo vas a entender mejor. Ver más.
Aprender estos fundamentos no solo te permite entender cómo se comporta el código, sino que te da las herramientas para pensar como un desarrollador y resolver problemas del mundo real con lógica y creatividad.
Una variable es un contenedor que guarda un valor. Ese valor puede cambiar durante la ejecución del programa (de ahí el nombre variable). Es como una etiqueta que le pones a una caja para saber qué hay dentro.
let nombre = "Zack";
const edad = 18;
var trabajo = "Recogelata";
Los tipos de datos son las diferentes clases de valores que puedes usar para construir tus programas. Cada tipo define qué puedes hacer con ese valor y cómo se comporta.
let numero = 42; // Número
let texto = "Hola, mundo!"; // Cadena de texto
let booleano = true; // Booleano (true o false)
let objeto = { nombre: "Juan", edad: 25 }; // Objeto
let arreglo = [1, 2, 3, 4, 5]; // Arreglo
Los operadores de comparación son símbolos o palabras especiales que permiten realizar operaciones con valores o variables. Piensa en ellos como herramientas que el lenguaje usa para comparar, calcular, asignar o tomar decisiones.
let a = 5;
let b = 10;
let resultado1 = (a == b); // Igualdad
let resultado2 = (a != b); // Desigualdad
let resultado3 = (a > b); // Mayor que
let resultado4 = (a < b); // Menor que
let resultado5 = (a >= b); // Mayor o igual que
let resultado6 = (a <= b); // Menor o igual que
let resultado7 = (a === b); // Igualdad estricta
let resultado8 = (a !== b); // Desigualdad estricta
Los operadores lógicos son símbolos que se usan para tomar decisiones basadas en condiciones. Son los que le dan lógica real al código, permiten combinar comparaciones y controlar el flujo del programa.
let a = 5;
let b = 10;
let resultado1 = (a > 0) && (b > 0); // AND lógico
let resultado2 = (a < 0) || (b > 0); // OR lógico
let resultado3 = !(a > b); // NOT lógico
Las estructuras de control o Condicionales son instrucciones que permiten tomar decisiones y repetir acciones en el código. Son como las señales de tráfico que guían el flujo del programa.
// Estructura condicional
if (a > b)
console.log("a es mayor que b");
}; else {
console.log("a no es mayor que b");
}
// Estructura de bucle
for (let i = 0; i < 5; i++) {
console.log(i);
{;
Los bucles son estructuras que permiten repetir un bloque de código varias veces. Son como una cinta transportadora que pasa por el mismo lugar una y otra vez.
// Bucle for
for (let i = 0; i < 5; i++) {
console.log(i);
}
// Bucle while
let j = 0;
while (j < 5) {
console.log(j);
j++;
} Las funciones son bloques de código que realizan una tarea específica. Puedes pensar en ellas como recetas que puedes seguir para obtener un resultado.
function suma(a, b) {
return a + b;
}
let resultado = suma(5, 10); // Llamada a la función
console.log(resultado); // Imprime 15
Los objetos son colecciones de propiedades y métodos. Puedes pensar en ellos como cajas que contienen diferentes tipos de datos y funciones.
let persona = {
nombre: "Juan",
edad: 25,
saludar: function() {
console.log("Hola, soy " + this.nombre);
}
};
persona.saludar(); // Llama al método saludar
// Imprime "Hola, soy Juan"
Los arreglos son colecciones de elementos. Puedes pensar en ellos como listas ordenadas de datos.
let numeros = [1, 2, 3, 4, 5];
console.log(numeros[0]); // Imprime 1
console.log(numeros.length); // Imprime la longitud del arreglo (5)
numeros.push(6); // Agrega un elemento al final del arreglo
console.log(numeros); // Imprime [1, 2, 3, 4, 5, 6]
El Ordenamiento por burbuja es un algoritmo sencillo que se utiliza para organizar elementos en una lista. Su funcionamiento se basa en recorrer la lista varias veces y comparar elementos vecinos, intercambiándolos si están en el orden incorrecto. En cada pasada, los valores más grandes “suben” progresivamente hacia el final, como si fueran burbujas que emergen en un líquido.
Este proceso se repite hasta que ya no se necesita hacer más intercambios, lo que indica que la lista está completamente ordenada. Aunque su implementación es fácil de entender, no es eficiente para listas grandes debido a la cantidad de comparaciones necesarias.
Para implementar el algoritmo de ordenamiento por burbuja, se siguen los siguientes pasos:
1. Tienes un array.
2. Lo recorres varias veces.
3. Comparas pares consecutivos.
4. Intercambias si es necesario.
5. Repites hasta que quede ordenado.
let numeros = [5, 3, 8, 4, 2];
console.log("Array original:", numeros);
function ordenarBurbuja(lista) {
// Variable que indica si hubo cambios en la iteración
let huboIntercambio;
do {
// Reiniciamos el indicador de intercambio al comienzo del ciclo
huboIntercambio = false;
for (let i = 0; i < lista.length - 1; i++) { let actual = lista [i];
letsiguiente = lista[i + 1];
// Si el actual es mayor que el siguiente, se deben intercambiar
if ( actual > siguiente) {
let temp = lista[i];
lista[i] = lista[i + 1];
lista[i + 1] = temp;
// Indicamos que hubo un intercambio
huboIntercambio = true;
// Mostramos el estado actual del array (opcional para visualizar)
console.log(`Intercambiado ${ actual} y ${siguiente}:`, lista);
}
}
// Si hubo al menos un intercambio, se vuelve a recorrer el array
} while (huboIntercambio);
return lista;
}
// Ejecutamos la función y guardamos el resultado
let resultadoFinal = ordenarBurbuja(numeros);
// Mostramos el resultado final en consola
console.log("Array ordenado:", resultadoFinal);
let numeros = [5, 3, 8, 4, 2];
console.log("Array original:", numeros);
function ordenarBurbuja(lista) {
// Variable que indica si hubo cambios en la iteración
let huboIntercambio;
do {
// Reiniciamos el indicador de intercambio al comienzo del ciclo
huboIntercambio = false;
for (let i = 0; i < lista.length - 1; i++) {
let actual = lista [i];
letsiguiente = lista[i + 1];
// Si el actual es mayor que el siguiente, se deben intercambiar
if ( actual > siguiente) {
let temp = lista[i];
lista[i] = lista[i + 1];
lista[i + 1] = temp;
// Indicamos que hubo un intercambio
huboIntercambio = true;
// Mostramos el estado actual del array (opcional para visualizar)
console.log(`Intercambiado ${ actual} y ${siguiente}:`, lista);
}
}
// Si hubo al menos un intercambio, se vuelve a recorrer el array
} while (huboIntercambio);
return lista;
}
// Ejecutamos la función y guardamos el resultado
let resultadoFinal = ordenarBurbuja(numeros);
// Mostramos el resultado final en consola
console.log("Array ordenado:", resultadoFinal);
¡Gran pregunta! Cuando interactuamos con el proceso de Bubble Sort en tiempo real, descubrimos varias cosas interesantes sobre algoritmos y la lógica detrás de la organización de datos. Algunas revelaciones clave incluyen:
Al jugar con Bubble Sort, podemos ver cómo los elementos "burbujear" hacia su posición correcta. Esto nos ayuda a entender qué significa comparar e intercambiar valores dentro de un conjunto de datos.
Cuando manipulamos el proceso, podemos notar que Bubble Sort no es el algoritmo más rápido. Observamos que hace muchas comparaciones innecesarias, especialmente en listas ya casi ordenadas, lo que nos lleva a pensar en algoritmos más eficientes como Quick Sort o Merge Sort.
Cuando experimentamos con diferentes conjuntos de datos, vemos que el orden inicial afecta cuántas iteraciones necesita Bubble Sort. Si la lista ya está casi ordenada, el número de intercambios disminuye. Esto nos hace reflexionar sobre cuándo usarlo y cuándo optar por otras estrategias.
Cuando podemos modificar el algoritmo en tiempo real, aprendemos de manera intuitiva. La interacción nos permite entender cómo cambian los datos con cada paso, fortaleciendo nuestra capacidad de diseñar soluciones algorítmicas más inteligentes.
He creado un quiz sobre el Ordenamiento de Burbuja, ¿te animas a intentarlo?
Haz clic en el siguiente botón para participar: