Universidad Nacional Autónoma de México

Facultad de Estudios Superiores Aragón

Ingeniería en Computación

Materia:

Estructura de datos

Profesor:
Blanco Bautista Roberto

Grupo:

1311

Nombre de los alumnos:

Manzano Montes Luis Raul

Método de burbuja

México, Nezahualcóyotl a 5 de diciembre del 2022.

 Método de Burbuja
El ordenamiento 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.
Es necesario revisar varias veces toda la lista hasta que no se necesiten
más intercambios, lo cual significa que la lista está ordenada. Este
algoritmo obtiene su nombre de la forma con la que suben por la lista
los elementos durante los intercambios, como si fueran pequeñas
"burbujas". También es conocido como el método del intercambio
directo. Dado que solo usa comparaciones para operar elementos, se
lo considera un algoritmo de comparación, siendo uno de los más
sencillos de implementar.

Ejemplo:

Tomemos como ejemplo los números: "9 6 5 8 2 1", que serán

ordenados de menor a mayor valor usando el método burbuja. Los
elementos siguientes resaltados están siendo comparados.
Diagrama de Flujo
 Código Fuente
Application
Main
package application;

import javafx.application.Application;

import javafx.stage.Stage;

import javafx.scene.Scene;

import javafx.scene.layout.BorderPane;

import javafx.scene.layout.Pane;

import javafx.fxml.FXMLLoader;

public class Main extends Application {

@Override

public void start(Stage primaryStage) {

try {

Pane root =
(Pane)FXMLLoader.load(getClass().getResource("VistaBurbuja.fxml"));

Scene scene = new Scene(root);

scene.getStylesheets().add(getClass().getResource("application.css").toExternalFo
rm());

//primaryStage.initStyle(StageStyle.UNDECORATED);

primaryStage.setScene(scene);

primaryStage.show();

} catch(Exception e) {

e.printStackTrace();

}
 }

public static void main(String[] args) {

launch(args);

VistaBurbujaController
package application;

import java.net.URL;

import java.util.Random;

import java.util.ResourceBundle;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

import fes.aragon.utilerias.dinamicas.listasimple.ListaSimple;

import javafx.application.Platform;

import javafx.event.ActionEvent;

import javafx.fxml.FXML;

import javafx.fxml.Initializable;

import javafx.scene.chart.BarChart;

import javafx.scene.chart.CategoryAxis;

import javafx.scene.chart.NumberAxis;
import javafx.scene.chart.XYChart;

import javafx.scene.control.Button;

public class VistaBurbujaController implements Initializable{

@FXML

private Button accion;

@FXML

private BarChart<String, Number> area;

@FXML

private Button btnAleatorio;

@FXML

private Button btnSalir;

private ListaSimple<Integer> lista = new ListaSimple<>();

final CategoryAxis xAxis = new CategoryAxis();

final NumberAxis yAxis = new NumberAxis();

private XYChart.Series<String, Number> series;

final String[] color = {"-fx-bar-fill: green", "-fx-bar-fill: red", "-fx-bar-fill: blue", "-fx-
bar-fill: yellow"};

private ScheduledExecutorService scheduledExecutorService;

 @FXML

void aleatorios(ActionEvent event) {

numerosAleatorios();

series.getData().clear();

for(int i=0; i < lista.getLongitud(); i++) {

series.getData().add(new XYChart.Data<>(String.valueOf(i),
lista.obtenerNodo(i)));

series.getData().get(i).getNode().setStyle(color[new
Random().nextInt(4)]);

if(scheduledExecutorService != null) {

scheduledExecutorService.shutdown();

@FXML

void evento(ActionEvent event) {

scheduledExecutorService =
Executors.newSingleThreadScheduledExecutor();

scheduledExecutorService.scheduleAtFixedRate(()->{

Platform.runLater(()->{

for(int i=0; i < lista.getLongitud(); i++) {

for(int j = lista.getLongitud()-1; j > i; j--) {

if(lista.obtenerNodo(j-1) > lista.obtenerNodo(j)) {

Integer aux = lista.obtenerNodo(j-1);

 lista.asignar(lista.obtenerNodo(j),j-1);

lista.asignar(aux, j);

String tmpEstilo =
series.getData().get(j).getNode().getStyle();

String tmpEstiloDos =
series.getData().get(j-1).getNode().getStyle();

series.getData().get(j).getNode().setStyle(tmpEstiloDos);

series.getData().get(j-
1).getNode().setStyle(tmpEstilo);

series.getData().get(j).setYValue(lista.obtenerNodo(j));

series.getData().get(j-
1).setYValue(lista.obtenerNodo(j-1));

break;

});

}, 0,1,TimeUnit.SECONDS);

@FXML

void eventoSalir(ActionEvent event) {

 if(scheduledExecutorService != null) {

scheduledExecutorService.shutdown();

Platform.exit();

@Override

public void initialize(URL arg0, ResourceBundle arg1) {

// TODO Auto-generated method stub

numerosAleatorios();

xAxis.setLabel("Time/s");

xAxis.setAnimated(false);

yAxis.setLabel("Value");

yAxis.setAnimated(false);

//idArea = new LineChart<>(xAxis, yAxis);

//area.setTitle("Metodo Burbuja");

area.setAnimated(false);

series = new XYChart.Series<>();

area.getData().add(series);

for(int i=0; i < lista.getLongitud(); i++) {

final XYChart.Data<String, Number>dato = new

XYChart.Data<>(String.valueOf(i), lista.obtenerNodo(i));

series.getData().add(dato);

dato.getNode().setStyle(color[new Random().nextInt(4)]);

}
 private void numerosAleatorios() {

lista = new ListaSimple<>();

Random rd = new Random();

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

lista.agregarEnCola(rd.nextInt(200));

Fes/aragon/utilerias/dinámicas/listasimple

ListaSimple
package fes.aragon.utilerias.dinamicas.listasimple;

public class ListaSimple<E> {

// METODOS QUE TENGO QUE HACER DE ESTA MAMADA

// eliminar nodo, tomando como parametro a eliminar un indice

// eliminar cola?

// eliminar cabeza?

// agregar en la cabezona
 // agregar en la colota

// checar si un pinshi dato esta en la perra lista

// imprimir la perra lista

// obtener un nodo dando el indice

/*

* PROBLEMA GENERAL DE LA ESTRUCTURA DE DATOS "lista" es que

no podemos saber

* quien esta "atras de nosotros" podemos saber quien esta adelante gracias
al

* "nodo siguiente" y tener una referencia gracias al enlace

*/

/*

* SOLUCION PARCIAL DEL PROBLEMA //en este constructor se le asigna

como

* "nodo siguiente" al nodo actual antes de hacer el cambio //para tener una

* referencia del enlace que se tiene, por que si no se le diera el siguiente

* //no se tendria ningun enlaze, es decir SE LE DA EL NODO ANTERIOR

* //resolviendo el problema "parcial" que tienen las listas y asi dando el

* anterior, que en este caso siempre va a ser la cabeza, por que estamos

* agregando en la cabeza, es decir, de arriba hacia arria si agregaramos

desde

* la cola, el nodo anterior que le dariamos es decir, el siguiente, seria cola

*
 */

// crear cabeza y cola para tener referencia del

// principio y final de la lista

protected Nodo<E> cabeza;

protected Nodo<E> cola;

protected int longitud = 0;

// el jodido constructor

// el constructor sirve para inizializar cosas antes de hacer cualquier mamada

public ListaSimple() {

// inizializar la cola y la cabeza

// por que arriba la estamos declarando pero no inicializando

cabeza = null;

cola = null;

public void agregarEnCabeza(E dato) {

// cabeza va a apuntar al nuevo nodo que se creo

// por que se agrega desde la cabeza y lo demas

// se "recorre"

// en este constructor se le asigna como "nodo siguiente" al nodo

actual antes

// de hacer el cambio

// para tener una referencia del enlace que se tiene, por que si no se
le diera
 // el siguiente

// no se tendria ningun enlaze, es decir SE LE DA EL NODO

ANTERIOR

// resolviendo el problema "parcial" que tienen las listas

// y asi dando el anterior, que en este caso siempre va a ser la cabeza,

por que

// estamos agregando en la cabeza, es decir, de arriba hacia arria

cabeza = new Nodo<E>(dato, cabeza);

// tenemos que verificar si es el primer nodo que se agrega

// si es el primer nodo que se agrega cola tiene que ser igual a null

// por que en el constructor se lo asignamos

// y cabeza es el nodo que acabamos de crear

// por lo que podemos deducir que si cola sigue siendo null solo hemos
agregado

// un dato

// pero si no es null, hay mas datos

if (cola == null) {

// aqui las 2 ya apuntan al mismo nodo que es el primero y

unico de la lista

// y ya que es el unico la cola y la cabeza son las mismas

cola = cabeza;

longitud++;

public void agregarEnCola(E dato) {

 if (cabeza == null) {

cabeza = cola = new Nodo<E>(dato);

} else {

cola.setSiguiente(new Nodo<E>(dato));

cola = cola.getSiguiente();

longitud++;

public void imprimirElementos() {

for (Nodo<E> temp = cabeza; temp != null; temp =

temp.getSiguiente()) {

System.out.println(temp.getDato());

public boolean eliminar(E dato) {

boolean borrado = false;

if (cabeza != null) {

if (cabeza == cola && dato.equals(cabeza.getDato())) {

cabeza = cola = null;

borrado = true;

longitud--;

} else if (dato == cabeza.getDato()) {

cabeza = cabeza.getSiguiente();
 borrado = true;

longitud--;

} else {

Nodo<E> prd, temp;

for (prd = cabeza, temp = cabeza.getSiguiente(); temp

!= null

&& !temp.getDato().equals(dato); prd =

prd.getSiguiente(), temp = temp.getSiguiente())

if (temp != null) {

borrado = true;

longitud--;

prd.setSiguiente(temp.getSiguiente());

if (temp == cola) {

cola = prd;

return borrado;

public int getLongitud() {

if (longitud < 0) {
 longitud = 0;

return longitud;

public boolean esVacia() {

return cabeza == null;

// REVISAR ESTA PENDEJADA

public void eliminarEnCabeza() {

if (cabeza != null) {

if (cabeza == cola) {

cabeza = cola = null;

longitud--;

} else {

cabeza = cabeza.getSiguiente();

longitud--;

// REVISAR LAS COMILLAS EN EL FOR

public void eliminarCola() {

if (cabeza != null) {

if (cabeza == cola) {
 cabeza = cola = null;

longitud--;

} else {

Nodo<E> temp;

for (temp = cabeza; temp.getSiguiente() != cola; temp

= temp.getSiguiente());

temp.setSiguiente(null);

cola = temp;

longitud--;

// REVISR ESTA PENDEJADA TAMBIEN

public E obtenerNodo(int indice) {

Nodo<E> temp = null;

if (indice <= longitud) {

temp = cabeza;

for (int contador = 0; contador < indice && temp != null;

contador++, temp = temp.getSiguiente())

if (temp != null) {

return temp.getDato();

} else {
 return null;

// REVISAR ESTA MAMADA TAMBIEN

public int estaEnLista(E dato) {

int indice;

Nodo<E> temp = null;

temp = cabeza;

for (indice = 0; indice < longitud && temp != null

&& temp.getDato().equals(dato); indice++, temp =

temp.getSiguiente())

if (temp != null) {

return indice;

} else {

return -1;

//

public boolean isInList(E dato, ListaSimple<E> lista) {

boolean isInList = false;

if(lista.esVacia()) {

return isInList;

}
 for(int i=0; i < lista.longitud; i++) {

if(dato == lista.obtenerNodo(i)) {

isInList = true;

return isInList;

public boolean eliminarEnInidce(int indice) {

boolean borrado = false;

if (indice >= 0 && indice <= longitud - 1) {

if (cabeza != null) {

if (cabeza == cola && indice == 0) {

cabeza = cola = null;

borrado = true;

longitud--;

} else if (indice == 0) {

cabeza = cabeza.getSiguiente();

borrado = true;

longitud--;

} else {

Nodo<E> prd, temp;

int contador = 1;
 for (prd = cabeza, temp =
cabeza.getSiguiente(); contador < indice; prd = prd

.getSiguiente(), temp =
temp.getSiguiente(), contador++)

if (temp != null) {

borrado = true;

longitud--;

prd.setSiguiente(temp.getSiguiente());

if (temp == cola) {

cola = prd;

return borrado;

// REVISAR ******************

//para insertar en la lista quitar el menos 1 en longitud

public boolean insertarEnIndice(E dato, int indice) {

boolean seInserto = false;

if (indice >= 0 && indice <= longitud) {

if (indice == 0) {
 this.agregarEnCabeza(dato);

seInserto = true;

} else {

Nodo<E> prv, temp = null;

int contador = 0;

for (prv = null, temp = cabeza; contador < indice;

contador++, prv = temp, temp = temp.getSiguiente())

prv.setSiguiente(new Nodo<E>(dato, temp));

longitud++;

seInserto = true;

return seInserto;

public boolean asignar(E dato, int indice) {

Nodo<E> temp = null;

if (indice <= longitud - 1) {

temp = cabeza;

for (int contador = 0; contador < indice && temp != null;

contador++, temp = temp.getSiguiente())

if (temp != null) {

temp.setDato(dato);
 return true;

} else {

return false;

public void asginar(E dato, E nuevoDato, boolean todos) {

Nodo<E> temp = null;

if (!todos) {

for (temp = cabeza; temp != null; temp = temp.getSiguiente())

{

if (temp.getDato().equals(dato)) {

temp.setDato(nuevoDato);

return;

} else {

for (temp = cabeza; temp != null; temp = temp.getSiguiente())

{

if (temp.getSiguiente().equals(dato)) {

temp.setDato(nuevoDato);

return;

}
 public E obtenerCabeza() {

return cabeza.getDato();

public E obtenerCola() {

return cola.getDato();

Nodo
package fes.aragon.utilerias.dinamicas.listasimple;

public class Nodo<E> {

private E dato;

private Nodo<E> siguiente;

//los constructores sirven para inicializar

//las cosas antes de hacer cualquier mamada

//vamos a crear 2 constructores para darle una solucion "parcial"

//al principal problema que tienen las listas *vea clase ListaSimple*

//construcrot para agregar en cola

public Nodo(E dato) {

this.dato = dato;
}

//constructor para instertar en cabeza

//le pedimos el dato del nodo que va a insertar

//y el nodo va a ser el siguiente, osea "inicio"

//se pasa como nodo siguiente la cabeza,

public Nodo(E dato, Nodo<E> siguiente) {

//usar this, por que el eclipse se apendeja

//y piensa que la variable local "dato"

//que es la que esta dentro del metodo

//la confunde con la variable global, (perteneciente a la clase)

this.dato = dato;

this.siguiente = siguiente;

//mamadas de getters y setters para obtener o cambiar

//el dato o el siguiente

public E getDato() {

return dato;

}
 public void setDato(E dato) {

this.dato = dato;

public Nodo<E> getSiguiente() {

return siguiente;

public void setSiguiente(Nodo<E> siguiente) {

this.siguiente = siguiente;

Conclusión
Se puede concluir que el método es sencillo de usar además de que se
puede utilizar en diversos aspectos en un programa en donde no se está
ordenando.

Este método es básico en la programación tanto como su contexto con

esto se podrá tener una idea de cómo ordenar elementos.

Se puede notar que optimizando el método se puede reducir los pasos

a seguir y así aumentar más la eficacia que tiene el programa, también
notamos que los programas elaborados se optimizaron el método y se
ordenaron de diferente manera para así poder ampliar el conocimiento
acerca de este método sin cambiar su contexto.