Estructuras de Datos: Pilas y Colas

En este primer bloque, se presenta la implementación de dos estructuras fundamentales: la Pila (Stack) y la Cola (Queue). Se demuestra el funcionamiento de los principios LIFO (Last In, First Out) y FIFO (First In, First Out).

import java.util.Stack;
import java.util.LinkedList;
import java.util.Queue;

public class Pilas {
    public static void main(String[] args) {
        
        // Creamos la Pila (LIFO/FILO)
        Stack<String> pila = new Stack<>();

        System.out.println("--- 1. LLENANDO LA PILA LIFO (PUSH) ---");
        // El dato entra y se pone "encima" del anterior
        
        pila.push("Plato 1"); 
        System.out.println("Entra: Plato 1");
        
        pila.push("Plato 2");
        System.out.println("Entra: Plato 2");
        
        pila.push("Plato 3"); // Este es el último en entrar
        System.out.println("Entra: Plato 3");

        System.out.println("\n--- 2. VACIANDO LA PILA (POP) ---");
        // El último que entró ("Plato 3") es el primero en salir (LIFO)
        
        while (!pila.isEmpty()) {
            String elemento = pila.pop(); // Saca el elemento de la cima
            System.out.println("Sale: " + elemento );
        }
        
        Queue<String> cola = new LinkedList<>();

        System.out.println("--- 1. LLENANDO LA PILA FIFO (OFFER/ADD) ---");
        
        cola.offer("Cliente 1"); // Llega el primero
        System.out.println("Llega: Cliente 1");
        
        cola.offer("Cliente 2");
        System.out.println("Llega: Cliente 2");
        
        cola.offer("Cliente 3");
        System.out.println("Llega: Cliente 3");

        System.out.println("\n--- 2. SALIDA DE LA PILA (POLL) ---");
        // El primero que llegó ("Cliente 1") sale primero
        
        while (!cola.isEmpty()) {
            String atendido = cola.poll(); // Saca al que está al frente
            System.out.println("Sale: " + atendido);
        }
    }
}

Esa es de las pilas.

Sistema de Inicio de Sesión con JOptionPane

A continuación, se muestra un ejemplo práctico de validación de datos utilizando la clase JOptionPane para la interacción con el usuario mediante ventanas emergentes.

import javax.swing.JOptionPane;

public class InicioSesion {
    public static void main(String[] args) {
      // 1. Pedir datos
        String usuario = JOptionPane.showInputDialog("Usuario:");
        String clave = JOptionPane.showInputDialog("Contraseña:");

        // 2. Validar (Usuario: "admin", Clave: "1234")
        // Usamos "texto".equals(variable) para evitar errores si das a Cancelar
        if ("admin".equals(usuario) && "1234".equals(clave)) {
            JOptionPane.showMessageDialog(null, "¡Bienvenido 'admin'!");
        } else {
            JOptionPane.showMessageDialog(null, "Datos incorrectos.");
        }  
    }
}

Inicio de sesión.

Algoritmos de Ordenamiento

Ordenamiento Simple y Genérico

Este ejemplo utiliza la clase ArrayList y métodos genéricos para desordenar y ordenar una lista de números del 1 al 100.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class OrdenamientoSimple {
    public static void main(String[] args) {
        // 1. Crear la lista del 1 al 100
        List<Integer> numeros = new ArrayList<>();
        for (int i = 1; i <= 100; i++) {
            numeros.add(i);
        }

        // 2. Desordenar y Mostrar
        desordenar(numeros);
        System.out.println("--- DESORDENADA ---");
        mostrar(numeros);

        // 3. Ordenar y Mostrar
        ordenar(numeros);
        System.out.println("\n--- ORDENADA ---");
        mostrar(numeros);
    }

    // Método Genérico para DESORDENAR (Usando Math)
    public static<T> void desordenar(List<T> lista) {
        for (int i = 0; i < lista.size(); i++) {
            // Elegimos una posición al azar
            int aleatorio = (int) (Math.random() * lista.size());

            // Intercambiamos el elemento actual (i) con el aleatorio
            T temporal = lista.get(i);
            lista.set(i, lista.get(aleatorio));
            lista.set(aleatorio, temporal);
        }
    }

    // Método Genérico para ORDENAR
    public static<T extends Comparable<T>> void ordenar(List<T> lista) {
        Collections.sort(lista);
    }

    // Método Genérico para MOSTRAR
    public static<T> void mostrar(List<T> lista) {
        System.out.println(lista);
    }
}

Ordenar 1 al 100.

Algoritmo de Ordenamiento Burbuja (Bubble Sort)

Implementación clásica del algoritmo de Burbuja para ordenar una lista de 100 números generados aleatoriamente.

import java.util.ArrayList;

public class Burbuja {
    public static void main(String[] args) {
        ArrayList<Integer> lista = new ArrayList<>();
        
        // Generar 100 números aleatorios (1 al 100)
        for (int i = 0; i < 100; i++) {
            lista.add((int)(Math.random() * 100) + 1);
        }

        System.out.println("Desordenada: " + lista);
        
        // Llamada simple (ya no necesitamos pasar izq ni der)
        ordenarBurbuja(lista);
        
        System.out.println("Ordenada:    " + lista);
    }
    
    // Método de Burbuja (Simple y sin recursividad)
    static void ordenarBurbuja(ArrayList<Integer> lista) {
        int n = lista.size();

        // Bucle 1: Repite el proceso n veces
        for (int i = 0; i < n - 1; i++) {
            
            // Bucle 2: Recorre la lista comparando vecinos
            for (int j = 0; j < n - i - 1; j++) {
                
                // Si el actual es mayor que el siguiente...
                if (lista.get(j) > lista.get(j + 1)) {
                    
                    // ...Intercambio (Swap)
                    int temp = lista.get(j);
                    lista.set(j, lista.get(j + 1));
                    lista.set(j + 1, temp);
                }
            }
        }
    }
}

Orden 1 al 100 burbuja.