MANUAL DE CODIGOS DE JAV

Yohan Rosendo Nava Solache

Estructura de datos
Contenido
1.- Gestión lista simplemente enlazada (agregar, modificar, recorrer, eliminar
y buscar)....................................................................................................2
2.- Gestión lista doblemente enlazada.........................................................8
3.- Gestión Lista ordenada simplemente enlazada......................................17
4.- Gestión Lista ordenada doblemente enlazada.......................................25
5.- Gestión Lista doblemente ligada, pila...................................................32
6.- Gestión Lista doblemente ligada, cola..................................................38
7.- Recursividad.......................................................................................44
8.-Gestión árbol binario de búsqueda (recorridos).....................................48
9.-Gestión burbuja....................................................................................53
10.-Gestión Quicksort...............................................................................59
11.-Gestión Shellsort................................................................................64
12.-Gestion Radix.....................................................................................70
13.-Gestion intercalación..........................................................................78
14.-Gestion mezcla directa........................................................................84
15.-Gestion mezcla natural........................................................................90
16.-Busqueda secuencial..........................................................................96
17.-Busqueda binaria..............................................................................100
18.-Busqueda por funciones de hash......................................................105
1.- Gestión lista simplemente enlazada
(agregar, modificar, recorrer, eliminar y
buscar)

CLASE - ListaSimplementeEnlazada
Esta clase implementa una lista simplemente enlazada, que es una estructura de
datos donde cada elemento (llamado nodo) tiene dos partes:

El dato que guarda y una referencia al siguiente nodo en la lista. En otras

palabras, cada nodo está "enlazado" al siguiente, formando una secuencia.

1. Atributo cabeza:

o La clase tiene un atributo llamado cabeza, que es una referencia al

primer nodo de la lista. Si la lista está vacía, cabeza será null.

2. Método agregar (int dato):

o Este método agrega un nuevo nodo al final de la lista. Si la lista está

vacía (es decir, cabeza es null), el nuevo nodo se convierte en el
primer nodo. Si la lista no está vacía, recorre los nodos hasta llegar
al último, y luego agrega el nuevo nodo al final.

3. Método recorrer ():

o Este método recorre toda la lista e imprime los datos de cada nodo.
Empieza desde la cabeza y va siguiendo los nodos hasta llegar al
final (null).

4. Método buscar (int dato):

o Este método busca si un dato existe en algún nodo de la lista.

Empieza desde la cabeza y recorre la lista comparando los datos de
cada nodo con el dato que estamos buscando. Si lo encuentra,
retorna true; si no, retorna false.

5. Método modificar (int datoViejo, int datoNuevo):

 Este método busca un nodo que tenga el dato datoViejo y lo reemplaza

con datoNuevo. Si encuentra el nodo, cambia el valor del dato y retorna
true. Si no encuentra el nodo con el dato a modificar, retorna false.
6. Método eliminar (int dato):

 Este método elimina un nodo con el dato especificado. Si el primer nodo

(cabeza) tiene el dato que queremos eliminar, simplemente lo elimina y
mueve la cabeza al siguiente nodo. Si el nodo a eliminar no es el primero,
recorre la lista hasta encontrarlo y lo elimina ajustando el enlace del nodo
anterior. Si no encuentra el nodo, retorna false.

CLASE – NODO

Esta clase representa a un nodo en una lista enlazada, donde cada nodo tiene un
valor (dato) y una referencia al siguiente nodo (siguiente). El constructor
simplemente inicializa estos valores cuando creamos un nuevo nodo.

1.- Atributo dato:

Este atributo almacena el valor o información que queremos guardar en el nodo.

En este caso, el dato es un número entero (int).

2.- Atributo siguiente:

Este atributo es una referencia al siguiente nodo de la lista. Si el nodo es el último,

este atributo será null, indicando que no hay más nodos después de él.

3.- Constructor Nodo (int dato):

El constructor se usa para crear un nuevo nodo. Recibe un valor entero (dato) y lo
asigna al atributo dato del nodo. El atributo siguiente se inicializa como null, ya
que, al principio, el nodo no está enlazado a ningún otro nodo.

CLASE – MAIN

La clase Main tiene como propósito principal demostrar cómo funciona la

lista simplemente enlazada definida en la clase ListaSimplementeEnlazada.

1. Crear un objeto de tipo ListaSimplementeEnlazada: Primero, se crea un

objeto llamado lista, que es de tipo ListaSimplementeEnlazada. Este
objeto representa la lista donde vamos a almacenar datos.

2. Agregar elementos a la lista: Se agregan tres números a la lista (10, 20 y

30) usando el método agregar. Esto va creando nodos en la lista y cada uno
apunta al siguiente. Al principio, la lista está vacía, pero después de agregar
los tres elementos, tiene tres nodos con los valores 10, 20 y 30.

3. Mostrar los elementos de la lista: Luego, se llama al método recorrer, que

recorre la lista y muestra sus elementos en el formato 10 -> 20 -> 30 -> null,
 indicando que 10 apunta a 20, y 20 a 30, y el último nodo apunta a null (fin
de la lista).

4. Buscar un elemento: Se usa el método buscar para verificar si el número

20 está en la lista. Este método devuelve true si encuentra el número, y
false si no lo encuentra.

5. Modificar un elemento: Luego, se modifica el número 20 por el número 25

usando el método modificar. Esto cambia el valor en el nodo que contiene
20 por 25.

6. Mostrar la lista después de la modificación: Después de modificar el

elemento, se vuelve a recorrer la lista con recorrer para ver que ahora la
lista es 10 -> 25 -> 30 -> null.

7. Eliminar un elemento: Finalmente, se elimina el número 10 de la lista con

el método eliminar. Esto elimina el primer nodo que contiene el valor 10.

8. Mostrar la lista después de eliminar: Después de la eliminación, la lista

se muestra nuevamente con recorrer, y ahora tiene los elementos 25 -> 30 -
> null.
 EJECUTADO

Al ejecutar el código, se crea una lista enlazada con los elementos 10, 20 y 30.
Luego, se verifica que el elemento 20 esté en la lista, se modifica 20 por 25, y
finalmente se elimina el primer elemento (10). Después de estas operaciones, la
lista queda con los elementos 25 y 30. El resultado final muestra que todo se
ejecutó correctamente.

PROPOSITOS/POSIBLES USOS

Propósitos del programa:

a) Agregar elementos: Permite añadir nuevos datos a la lista.

b) Modificar elementos: Cambia el valor de un elemento ya existente en la

lista.

c) Recorrer la lista: Examina todos los elementos uno por uno, útil para
visualizar o procesar los datos.

d) Eliminar elementos: Borra elementos específicos de la lista.

e) Buscar elementos: Localiza un dato específico en la lista.

Posibles usos:

a) Gestión de tareas: Registrar tareas pendientes y actualizarlas.

b) Sistemas de inventario: Almacenar productos, buscarlos o eliminarlos.

c) Contactos personales: Guardar nombres y números de teléfono con

opciones de búsqueda o edición.
2.- Gestión lista doblemente enlazada
CLASE - ListaDoblementeEnlazada
1. Atributos de la Clase ListaDoblementeEnlazada:

 private Nodo cabeza;

Este es el primer nodo de la lista. Si la lista está vacía, será null. La cabeza
sirve para acceder al primer elemento de la lista.

 private Nodo cola;

Este es el último nodo de la lista. Si la lista está vacía, también será null. La
cola se utiliza para acceder al último nodo de la lista.

2. Constructor de la Clase ListaDoblementeEnlazada:

 public ListaDoblementeEnlazada ():

a) El constructor inicializa tanto la cabeza como la cola de la lista en null, lo

que significa que la lista comienza vacía.
b) Si luego agregamos nodos, se actualizarán los valores de la cabeza y la
cola de acuerdo con la lógica de la lista doblemente enlazada.

3. Métodos de la Clase ListaDoblementeEnlazada:

1. public void agregar (int dato)

a) Este método agrega un nuevo nodo con el valor dato al final de la lista.
b) Si la lista está vacía (cabeza == null), el nuevo nodo se convierte tanto en
la cabeza como en la cola de la lista.
c) Si la lista ya tiene nodos, el nuevo nodo se conecta al final de la lista,
actualizando los punteros siguiente y anterior de los nodos involucrados.

2. public void recorrerDesdeCabeza ()

a) Este método recorre la lista desde el primer nodo hasta el último.
b) Utiliza un bucle while que recorre cada nodo, imprimiendo el valor
almacenado (dato) hasta llegar al final de la lista (cuando el puntero
siguiente es null).

3. public void recorrerDesdeCola ()

a) Este método recorre la lista desde el último nodo hasta el primero.

b) Similar al método anterior, pero en este caso, empieza desde la cola y

sigue los punteros anterior.
4. public boolean buscar (int dato)

a) Este método busca un valor específico en la lista.

b) Si encuentra un nodo que contiene el valor dato, devuelve true. Si

recorre toda la lista sin encontrar el dato, devuelve false.

5. public boolean eliminar (int dato)

a) Este método elimina un nodo que contiene el valor dato.

b) Si el nodo a eliminar es el primero (cabeza), se actualiza la cabeza a su

siguiente nodo.

c) Si el nodo a eliminar está en el medio o al final, se ajustan los punteros

siguiente y anterior de los nodos circundantes para que se "salte" el
nodo eliminado.
 CLASE – NODO

1. Atributos de la Clase Nodo:

 int dato;

a) Este atributo es un entero que almacena el valor que queremos guardar en

el nodo. En este caso, el nodo guardará un número entero, pero podría ser
cualquier tipo de dato, dependiendo de las necesidades de la lista (por
ejemplo, un String o un objeto de otra clase).

6. Nodo siguiente;

a) Este atributo es un puntero (referencia a otro objeto de tipo Nodo) que

apunta al siguiente nodo en la lista.

b) Si este nodo es el último en la lista, el puntero siguiente se establece en

null, lo que indica que no hay más nodos después de él.

7. Nodo anterior;

a) Este atributo es un puntero (referencia a otro objeto de tipo Nodo) que

apunta al nodo anterior en la lista.

b) Si este nodo es el primero en la lista, el puntero anterior se establece en

null, lo que indica que no hay más nodos antes de él.
2. Constructor de la Clase Nodo:

 public Nodo (int dato)

a) El constructor de la clase Nodo se utiliza para crear una nueva instancia

de un nodo, tomando como argumento el valor dato que debe almacenar el
nodo.

CLASE – MAIN

La clase Main sirve para probar y mostrar cómo interactuar con la estructura de
datos ListaDoblementeEnlazada, creando el objeto listo y ejecutando las
operaciones sobre ella.
1.- Creación de un objeto de la lista:

 Se crea un objeto de la clase ListaDoblementeEnlazada llamado lista.

Esto nos da acceso a todos los métodos definidos en esa clase para
manipular la lista.

2.- Agregar elementos a la lista:

 Se utilizan tres llamadas al método agregar () para insertar los elementos

10, 20, 30, 40, 50 y 60 en la lista. Cada vez que se llama a este método, un
nuevo nodo se agrega al final de la lista.

3.- Recorrer la lista desde la cabeza:

 Se llama al método recorrerDesdeCabeza (), que recorre la lista desde el

primer nodo (cabeza) hacia el último nodo, imprimiendo los datos de cada
nodo. Esto nos permite ver los elementos que están en la lista después de
haber agregado los tres números.

4.- Recorrer la lista desde la cola:

 Similar al paso anterior, pero esta vez, se recorre la lista desde el último
nodo (cola) hasta el primero. Se usa el método recorrerDesdeCola ().
5.- Buscar un elemento en la lista:

 Se llama al método buscar () para verificar si el valor 20 está presente en la

lista. El método retorna true si encuentra el valor y false si no lo encuentra.

6.- Eliminar un elemento de la lista:

 Se llama al método eliminar () para eliminar el nodo que contiene el valor

20. Si el nodo es encontrado y eliminado, el método retorna true; de lo
contrario, false.

7.- Recorrer la lista después de eliminar un elemento:

 Finalmente, después de eliminar el nodo con el valor 20, se vuelve a

recorrer la lista desde la cabeza para ver cómo ha cambiado la lista.
 EJECUTADO

Al ejecutar el código, se crea una lista enlazada con los elementos 10, 20 y 30.
Luego, se verifica que el elemento 20 esté en la lista, se modifica 20 por 25, y
finalmente se elimina el primer elemento (10). Después de estas operaciones, la
lista queda con los elementos 25 y 30. El resultado final muestra que todo se
ejecutó correctamente.

PROPOSITOS/POSIBLES USOS

Propósitos del programa:

 Agregar elementos: Inserta nuevos datos en la lista, ya sea al inicio, al final

o en posiciones específicas.

 Modificar elementos: Actualiza el valor de un nodo existente.

 Buscar elementos: Localiza nodos en la lista según su contenido.

Posibles usos:

 Gestión de música o videos: Crear una lista de reproducción que pueda

recorrer en cualquier dirección.

 Sistemas de edición: Implementar deshacer/rehacer en aplicaciones al

almacenar acciones realizadas.
 3.- Gestión Lista ordenada simplemente
enlazada
CLASE - ListaOrdenadaGUI

1. Atributos principales de la clase

private Nodo cabeza;
a) Este atributo cabeza representa el inicio de la lista. Es un puntero al primer
nodo de la lista enlazada. Si la lista está vacía, cabeza es null.
2. Métodos de la lista
a) Insertar -- 20-35
Este método añade un número a la lista manteniendo el orden ascendente.
 Si la lista está vacía o el número es menor que el primero, el nuevo nodo se
convierte en la nueva cabeza.
 Si el número debe ir en algún lugar del medio o al final, se recorre la lista
hasta encontrar su posición correcta y se inserta allí.

b) Mostrar – 36-47
 Devuelve una representación de la lista enlazada como una cadena.
 Recorre cada nodo desde la cabeza hasta el final y construye una cadena
con los números separados por ->

c) Buscar – 48-59
 Busca un número en la lista.
 Devuelve true si el número está, y false si no.
d) Eliminar – 60-83

Elimina un número de la lista, devuelve true si se eliminó, y false si no se encontró

 Si el número está en la cabeza, actualiza la cabeza al siguiente nodo.

 Si está en algún lugar del medio o al final, recorre la lista hasta encontrarlo
y lo elimina actualizando los punteros.

3. Interfaz gráfica – (84 – 120)

Configuración de los elementos de la ventana:

a) JFrame frame = new JFrame("Gestión de Lista Ordenada"); 86-89

 JFrame: Crea una nueva ventana, que será el contenedor principal de
nuestra aplicación.
 "Gestión de Lista Ordenada": Establece el título que aparecerá en la
barra de título de la ventana.

b) JTextArea textArea = new JTextArea(); 92-95

  JTextArea: Crea un área de texto donde se mostrarán los elementos de la
lista. Es como un cuadro de texto de múltiples líneas.

c) JPanel panel = new JPanel(new GridLayout(4, 2, 5, 5)); 97-99

 JPanel: Crea un panel, que es un contenedor para otros componentes.
 GridLayout(4, 2, 5, 5): Establece un diseño de cuadrícula para el panel,
con 4 filas y 2 columnas. Los números 5 y 5 indican los espacios entre los
componentes, tanto horizontal como verticalmente.

JTextField txtInsertar = new JTextField();

JTextField txtBuscar = new JTextField();

JTextField txtEliminar = new JTextField();

JButton: Crea botones con los textos: "Insertar", "Buscar" y "Eliminar". Al
hacer clic en estos botones, se activarán las acciones correspondientes (que aún
no están implementadas en este código).

JButton btnInsertar = new JButton("Insertar");

JButton btnBuscar = new JButton("Buscar");

JButton btnEliminar = new JButton("Eliminar");

4. Funcionalidad de los botones – (122-169)

A) insertar

Cuando el usuario hace clic en el botón Insertar:

1. Toma el número del campo de texto.
2. Lo inserta en la lista.
3. Actualiza el área de texto con la lista actual.
4. Limpia el campo de texto.
B) Buscar

Cuando el usuario hace clic en Buscar:

1. Toma el número del campo.

2. Verifica si está en la lista.

3. Muestra un mensaje indicando si se encontró o no.

C) Eliminar

Cuando el usuario hace clic en Eliminar:

1. Toma el número del campo.

2. Intenta eliminarlo.

3. Muestra un mensaje indicando si se eliminó o no.

4. Actualiza el área de texto.

D) Mostrar ventana

 setVisible(true) : Le dice al sistema que ahora queremos que la ventana

sea visible en la pantalla.
 main: Es el método principal que crea y lanza la aplicación.
 La línea new ListaOrdenadaGUI(); crea una instancia de la clase
ListaOrdenadaGUI. Al instanciar esta clase, se ejecuta su constructor

Ejecutado

El programa "Gestión Lista ordenada simplemente enlazada" permite manejar una

lista de datos siempre organizados en un orden específico, permitiendo agregar,
modificar, eliminar, buscar y recorrer los elementos de manera eficiente.
 PROPOSITOS/POSIBLES USOS

Propósitos del programa:

 Agregar elementos en orden: Inserta nuevos datos en la posición correcta

para mantener el orden establecido.

 Eliminar elementos: Borra nodos específicos y reestructura la lista para

preservar el orden.

 Buscar elementos: Localiza un nodo específico, aprovechando que la lista

está ordenada para hacerlo más eficientemente.

Posibles usos:

 Lista de contactos: Almacenar nombres ordenados alfabéticamente.

 Gestión de calificaciones: Registrar puntajes de estudiantes en orden de

menor a mayor.

 Inventarios organizados: Controlar productos según su código o precio.

4.- Gestión Lista ordenada doblemente enlazada
CLASE - ListaDobleEnlaza
ATRIBUTOS:

1.- inicio: Referencia al primer nodo de la lista.

2.- fin: Referencia al último nodo de la lista.

3.- Cuando la lista está vacía, ambos son null.

METODOS:

1. agregarAlInicio:

A.-Crea un nuevo nodo y lo coloca al principio de la lista.

B.-Si la lista está vacía, ese nodo será tanto el inicio como el fin.

C.-Si la lista ya tiene elementos, el nuevo nodo apunta al nodo actual de inicio
como siguiente, y el nodo actual de inicio apunta hacia atrás al nuevo nodo como
anterior.

2. agregarAlFinal:

A.-Crea un nuevo nodo y lo coloca al final de la lista.

B.-Similar a agregarAlInicio, pero aquí se actualizan los punteros del nodo que
está en el último lugar (fin).

3. mostrarInicioAFin:

A.- Recorre la lista desde el nodo inicio hasta el nodo fin usando el puntero
siguiente.

B.- Imprime los valores de los nodos uno por uno.

4. mostrarFinAInicio:

A.-Es similar al método anterior, pero recorre la lista desde el nodo fin hacia el
nodo inicio usando el puntero anterior.
5. eliminarNodo:

A.-Busca un nodo que contenga el valor especificado (dato).

Si el nodo existe:

 Lo elimina ajustando los punteros de los nodos vecinos.

Si no existe:

 Muestra un mensaje de error.

CLASE - MAIN
Estructura principal (do-while) – (110-151)

Mantiene el programa ejecutándose hasta que el usuario elija salir (opción 6).

Llama a los métodos correspondientes según la elección del usuario.

Menú de opciones (110-120) - Muestra un menú que permite al usuario

interactuar con la lista:

System.out.println("Menú de Opciones:");

System.out.println-("1. Agregar un Nodo al Inicio");

System.out.println-("2. Agregar un Nodo al Final");

System.out.println-("3. Mostrar la Lista de Inicio a Fin");

System.out.println-("4. Mostrar la Lista de Fin a Inicio");

System.out.println-("5. Eliminar un Nodo");

System.out.println-("6. Salir");
 CLASE - NODO

Cada nodo almacena:

a) dato: El valor que contiene el nodo.

b) anterior: Un puntero o referencia al nodo anterior en la lista.
c) siguiente: Un puntero o referencia al nodo siguiente en la lista.

Constructor:

a) Inicializa un nuevo nodo con un valor (dato) y establece las referencias

anterior y siguiente como null al crearlo.
EJECUTADO
El programa implementa una lista doblemente enlazada que permite agregar
nodos al inicio, mostrar la lista en orden de inicio a fin o viceversa, y eliminar
nodos por valor. Al ejecutarlo, el usuario selecciona opciones de un menú
interactivo; en este caso, agregó varios nodos al inicio, lo que organizó la lista en
orden inverso a su ingreso. Finalmente, mostró la lista recorriéndola de inicio a fin,
evidenciando la correcta manipulación y estructura de los nodos.

PROPOSITOS/POSIBLES USOS

Propósitos del programa:

 Agregar elementos en orden: Inserta datos de forma que siempre se

mantenga el orden establecido (por ejemplo, numérico o alfabético).

 Modificar elementos: Cambia el valor de un nodo y ajusta su posición para

conservar el orden.

 Recorrer la lista: Permite desplazarse por los elementos en ambas

direcciones, de inicio a fin y viceversa.

 Eliminar elementos: Borra nodos específicos y reestructura la lista para

mantener el orden.

 Buscar elementos: Localiza datos de manera eficiente, aprovechando que

la lista está ordenada.

Posibles usos:

 Gestión de libros en una biblioteca: Organizar títulos o autores de forma

alfabética.

 Control de stock: Registrar productos en orden de precio o cantidad

disponible.

 Sistemas de registro académico: Listar estudiantes por calificaciones o

nombres ordenados.

 Organización de agendas: Manejar eventos o tareas según fecha y hora.

5.- Gestión Lista doblemente ligada, pila
CLASE – PilaDoblementeLigada (15-94)
Atributo:

 cima: Es la referencia al nodo que se encuentra en la cima de la pila.

Inicialmente, está en null, ya que la pila está vacía.
 Constructor: Inicializa la pila vacía, poniendo cima en null.

Métodos:

public void apilar(int dato):

 Inserta un nuevo elemento en la cima de la pila.

 Si la pila está vacía (cima == null), se crea un nuevo nodo y se asigna a la
cima.
 Si la pila no está vacía, se ajustan los punteros: el nuevo nodo se coloca
antes de la cima y se actualizan las referencias siguiente y anterior
adecuadamente.

public void desapilar() :

 Elimina el nodo en la cima de la pila.

 Si la pila está vacía, muestra un mensaje.

 Si no, se elimina el nodo de la cima, y si la pila no queda vacía, se ajusta el

puntero anterior del nuevo nodo en la cima a null.
public void mostrarPila():

 Muestra todos los elementos de la pila desde la cima hasta la base.

 Si la pila está vacía, muestra un mensaje. Si no, recorre los nodos
empezando desde la cima e imprime sus valores.

public void recorrerPila(String direccion):

 Permite recorrer la pila en dos direcciones: hacia la derecha (de cima a

base) o hacia la izquierda (de base a cima).
 Si la dirección es "derecha", recorre la pila desde la cima hasta la base.
 Si la dirección es "izquierda", recorre la pila desde la base hasta la cima.
 Si la dirección no es válida, muestra un mensaje.
 CLASE MAIN (95-140)

 La clase principal maneja la interacción con el usuario.

 El usuario puede elegir entre varias opciones como apilar, desapilar,
mostrar o recorrer la pila. El bucle do-while sigue pidiendo opciones hasta
que el usuario elige salir.

CLASE NODO
Atributos:

 dato: Almacena el valor de cada nodo (es un número entero).

 siguiente: Referencia al siguiente nodo en la pila.

 anterior: Referencia al nodo anterior en la pila.

Constructor: El constructor recibe un valor entero y asigna ese valor al atributo

dato, mientras que siguiente y anterior se inicializan en null.

EJECUTADO
El programa permite gestionar una pila doblemente enlazada de manera eficiente,
realizando las operaciones de apilar, desapilar, mostrar y recorrer los elementos
en ambas direcciones.

1. Apilar: Los datos se insertan correctamente en la cima de la pila.

2. Mostrar y recorrer: La pila se puede visualizar tanto desde la cima hacia la

base como viceversa, gracias a las referencias siguiente y anterior.

3. Orden de los elementos: La pila sigue el orden LIFO (último en entrar,

primero en salir), lo cual es evidente en la secuencia de apilamiento y
recorrido.

4. Interfaz amigable: El menú interactivo facilita el uso y pruebas del programa.

PROPOSITOS/POSIBLES USOS

Propósitos del programa:

 Implementar una pila: Usa una lista doblemente ligada para manejar
elementos en una estructura tipo LIFO (Último en entrar, primero en salir).

 Agregar elementos (push): Inserta datos en la parte superior de la pila.

 Eliminar elementos (pop): Quita el elemento más reciente añadido.

 Recorrer la pila: Explora los elementos desde el tope hacia la base o

viceversa.

Posibles usos:

 Deshacer/rehacer acciones: Almacena cambios en una aplicación de texto

o diseño.

 Gestión de llamadas: Manejar historial de llamadas recientes en

dispositivos móviles.
6.- Gestión Lista doblemente ligada, cola
CLASE ColaListaDoble
La clase ColaListaDoble implementa la estructura de la cola usando una lista
doblemente enlazada.

Atributos:

 cabeza: Apunta al primer nodo de la cola.

 cola: Apunta al último nodo de la cola.

Constructor: Inicializa la cola vacía estableciendo cabeza y cola como null.

METODOS:

public void encolar(int dato): (24-36)

Agrega un nuevo nodo al final de la cola.

1. Crea un nuevo nodo con el dato proporcionado.

2. Si la cola está vacía (cola == null):

3. Si ya hay elementos:

a) El nodo actual al final (cola) apunta al nuevo nodo mediante su atributo

siguiente.

b) El nuevo nodo apunta al nodo anterior mediante su atributo anterior.

c) La cola se actualiza para apuntar al nuevo nodo.

public void desencolar(): (37-51)

Elimina el primer elemento de la cola (FIFO).

1. Si la cola está vacía (cabeza == null), muestra un mensaje.

2. Si hay elementos:

a) Muestra el valor del nodo eliminado.

b) Actualiza la cabeza para que apunte al siguiente nodo.

c) Si el nuevo nodo cabeza es null (la cola quedó vacía), también establece
la cola como null.

d) De lo contrario, actualiza el atributo anterior del nuevo nodo cabeza a

null

public void mostrar(): 52-67

Recorre la lista desde la cabeza hasta el final (cola) y muestra los valores de los
nodos.

1. Si la cola está vacía (cabeza == null), muestra un mensaje.

2. Si hay elementos:

a) Usa un bucle while para recorrer cada nodo, imprimiendo su valor (dato).

b) Avanza al siguiente nodo con actual = actual.siguiente.

Clase Principal: GestionColaListaDoble: 68-108

Se crea una instancia de la clase ColaListaDoble y un objeto Scanner para leer la

entrada del usuario.

Se muestra un menú con opciones para realizar diferentes operaciones

Permite al usuario introducir varios valores separados por espacios .

Usa scanner.nextLine() para leer la línea completa y luego divide los valores
con.split(" ").

Cada valor se convierte a entero (Integer.parseInt) y se agrega a la cola con el

método encolar.
 EJECUTADO

El programa demuestra cómo gestionar una cola utilizando una lista doblemente
enlazada, implementando operaciones clave como agregar elementos, eliminarlos
siguiendo el principio FIFO (First In, First Out) y visualizar el estado actual de la
cola. Permite al usuario agregar múltiples valores consecutivos de manera
sencilla, mostrando cada acción realizada en tiempo real. Su diseño flexible y
funcional es ideal para entender la estructura y comportamiento de una cola
dinámica, destacando su utilidad en aplicaciones que requieren manejo eficiente
de datos en orden secuencial.
 PROPOSITOS/POSIBLES USOS

Propósitos del programa:

 Implementar una cola: Usa una lista doblemente ligada para manejar
elementos en una estructura tipo FIFO (Primero en entrar, primero en salir).

 Agregar elementos (enqueue): Inserta datos al final de la cola.

 Eliminar elementos (dequeue): Retira el elemento del frente de la cola.

 Consultar el frente y el final: Permite ver los elementos en ambos

extremos sin eliminarlos.

 Recorrer la cola: Explora los elementos en orden, desde el frente hasta el

final o viceversa.

Posibles usos:

 Gestión de turnos: Manejar filas de espera en bancos o servicios al

cliente.

 Colas de impresión: Administrar documentos enviados a una impresora en

el orden en que se reciben.

 Sistemas de mensajería: Procesar mensajes en aplicaciones en tiempo

real.

 Simulación de procesos: Modelar eventos en sistemas como tráfico,

logística o procesamiento de datos.
 7.- Recursividad

Definición del Método calcularFactorial

public static int calcularFactorial(int n):

Este método toma un parámetro, n, que es el número cuya factorial vamos a

calcular. int indica que el método devuelve un número entero, que será el
resultado del cálculo de la factorial.

Caso Base (Condición de Parada de la Recursión)

Este bloque maneja el caso base de la recursión, es decir, la condición que hace
que la recursión se detenga. Sabemos que la factorial de 0 o 1 es siempre 1. Así
que, si el valor de n es 0 o 1, el programa imprime un mensaje que indica que está
en el caso base y retorna 1.
Caso Recursivo (Llamada a Sí Mismo)

Si n es mayor que 1, el programa imprime un mensaje que muestra la operación

que está a punto de realizarse, que es multiplicar n por la factorial de n-1. Luego,
llama a calcularFactorial(n - 1), lo que provoca que el método se ejecute
nuevamente con el valor n - 1, y así sucesivamente hasta que se llega al caso
base.

Método main (Ingreso de Datos y Llamada a calcularFactorial)

El método main se ejecuta cuando el programa comienza. Primero, creamos un

objeto Scanner para leer datos desde la consola. Luego, se solicita al usuario que
ingrese un número para calcular su factorial. El número ingresado se guarda en la
variable número.

Validación de Entrada (Número Negativo)

Si el número ingresado es negativo, se imprime un mensaje indicando que la

factorial no está definido para números negativos, ya que, matemáticamente, el
factorial solo está definido para números enteros no negativos.
Llamada al Método Recursivo y Visualización del Resultado

Si el número es válido (no negativo), se imprime un mensaje que indica que se va

a mostrar el proceso de cálculo. Luego, se llama al método calcularFactorial
pasando el número ingresado, y el resultado se almacena en la variable resultado.
Finalmente, se imprime el resultado final.

EJECUTADO

EJECUTADO: El programa solicita un número al usuario (en este caso, 6) para

calcular su factorial. A través de la recursión, descompone el cálculo de 6! en
subproblemas más pequeños, como 6 * 5!, 5 * 4!, y así sucesivamente, hasta
llegar al caso base de 1! = 1. A medida que se resuelven las llamadas recursivas,
los resultados se multiplican y se retornan, mostrando cada paso. Finalmente, el
programa imprime el resultado de 6! = 720, indicando que el cálculo fue exitoso,
junto con el tiempo que tomó completarlo.
 PROPOSITOS/POSIBLES USOS

Propósitos del programa:

 Resolver problemas mediante recursión: Implementa soluciones

dividiendo un problema en subproblemas más pequeños del mismo tipo.

 Llamadas repetitivas: Utiliza funciones que se llaman a sí mismas hasta

alcanzar una condición base.

Posibles usos:

 Matemáticas: Resolver problemas como el cálculo de potencias, factoriales

o sumatorias.

 Estructuras de datos: Recorrer árboles binarios o grafos.

 Sistemas de archivos: Explorar directorios y archivos en forma jerárquica.

8.-Gestión árbol binario de búsqueda (recorridos)
CLASE BinarySearchTree
METODOS:

Método insert(int data):

 Inserta un nuevo valor (data) en el árbol.

 Llama al método recursivo insertRec, que maneja la lógica de inserción en
el árbol.

Método insertRec(Node root, int data):

Método recursivo para insertar un valor en el árbol siguiendo las reglas del árbol
binario de búsqueda:

 Si el valor es menor que el nodo actual, se va al subárbol izquierdo.

 Si el valor es mayor que el nodo actual, se va al subárbol derecho.

 Base case: Si el nodo actual es null, significa que hemos encontrado una
posición vacía en el árbol donde podemos insertar el nuevo nodo. Creamos
un nuevo nodo con el valor data y lo devolvemos.

 Recursión: Si el valor es menor que el nodo actual, se llama recursivamente

al subárbol izquierdo. Si es mayor, se llama al subárbol derecho. De este
modo, el valor se va insertando en el lugar adecuado del árbol.
Método inorder():

Llama al método recursivo inorderRec para realizar el recorrido en orden (in-order)

del árbol. Este método inicia el recorrido desde la raíz del árbol.

Método inorderRec(Node root):

Realiza el recorrido en orden del árbol (recorrido in-order).

 Recorrido en orden significa visitar el subárbol izquierdo, luego el nodo

actual y luego el subárbol derecho.

 Si el nodo no es null, se realiza el recorrido recursivo sobre el subárbol

izquierdo (inorderRec(root.left)), luego se imprime el valor del nodo
(System.out.print(root.data + " ")), y finalmente se recurre al subárbol
derecho (inorderRec(root.right)).

Método preorder():

Llama al método recursivo preorderRec para realizar el recorrido en preorden (pre-

order). Este método inicia el recorrido desde la raíz del árbol.
Método preorderRec(Node root):

Realiza el recorrido en preorden del árbol (recorrido pre-order).

 Recorrido en preorden significa visitar el nodo actual primero, luego el

subárbol izquierdo, y después el subárbol derecho.

 Si el nodo no es null, se imprime el valor del nodo

(System.out.print(root.data + " ")), luego se recurre al subárbol izquierdo
(preorderRec(root.left)), y finalmente al subárbol derecho
(preorderRec(root.right)).

Método postorder():

Llama al método recursivo postorderRec para realizar el recorrido en postorden

(post-order).Este método inicia el recorrido desde la raíz del árbol.

Realiza el recorrido en postorden del árbol (recorrido post-order).

 Recorrido en postorden significa visitar primero el subárbol izquierdo,

luego el subárbol derecho y finalmente el nodo actual.
  Si el nodo no es null, se recurre primero al subárbol izquierdo
(postorderRec(root.left)),luego al subárbol derecho
(postorderRec(root.right)), y al final se imprime el valor del nodo
(System.out.print(root.data + " ")).

EJECUTADO

Al ejecutar el código, insertas 6 valores (1, 2, 3, 4, 5, 6) en el árbol binario. Debido

a que están en orden ascendente, el árbol se sesga hacia la derecha. Los
recorridos muestran lo siguiente:

 In-order: Imprime los valores en el mismo orden: 1 2 3 4 5 .

 Pre-order: Imprime los valores en el orden de inserción: 1 2 3 4 5 .

 Post-order: Imprime los valores en orden inverso: 5 4 3 2 1.

PROPOSITOS/POSIBLES USOS

Propósitos del programa:

 Llamadas repetitivas: Utiliza funciones que se llaman a sí mismas hasta

alcanzar una condición base.

 Simplificar código: Reduce la necesidad de bucles complejos al expresar

soluciones de manera más directa.

Posibles usos:

 Estructuras de datos: Recorrer árboles binarios o grafos.

 Sistemas de archivos: Explorar directorios y archivos en forma jerárquica.

 Algoritmos avanzados: Aplicar técnicas como mergesort o quicksort para
ordenar datos.

9.-Gestión burbuja
CLASE - GestionBurbuja
1. Clase Principal y Método main:

a) GestionBurbuja es el nombre de la clase que contiene todo el programa.

En Java, el nombre de la clase debe coincidir con el nombre del archivo.
b) El método main es el punto de entrada del programa. Aquí comienza la
ejecución.

2. Lectura del Tamaño del Arreglo

a) Se crea un objeto Scanner para leer datos ingresados por el usuario.

b) [n] almacena el número de elementos que el usuario quiere ordenar.
c) numeros es un arreglo de enteros con tamaño n que se llenará con los
números proporcionados.
3. Entrada de los Números

a) Un bucle for recorre desde 0 hasta n-1 para llenar el arreglo.

b) En cada iteración, el programa solicita un número al usuario y lo almacena
en numeros[i].
 4. Mostrar el Arreglo Inicial

a) Se llama al método mostrarArreglo para imprimir los números que el

usuario ingresó antes de realizar cualquier ordenación.
5. Método de Ordenación burbuja

Llamamos al método burbuja, que contiene el algoritmo principal de ordenación.

Le pasamos el arreglo numeros como parámetro para que trabaje directamente
sobre él.

6. Implementación del Método burbuja

a) Bucle Externo : Este bucle controla el número de pasadas necesarias
para ordenar el arreglo. Se ejecuta n-1 veces porque en cada pasada se
posiciona un número en su lugar correcto, y no es necesario volver a
evaluarlo.

b) Bucle Interno: Este bucle recorre los elementos aún no ordenados.

Compara cada par de elementos consecutivos (arr[j] y arr[j+1]) para
decidir si necesitan intercambiarse.

c) Condición de Intercambio: Si arr[j] es mayor que arr[j+1], significa que

están en el orden incorrecto, por lo que se intercambian:
1) Se guarda temporalmente arr[j] en temp.
2) arr[j] toma el valor de arr[j+1].
3) arr[j+1] toma el valor de temp.
 4) Después de cada intercambio, se llama a mostrarArreglo para
imprimir el estado actual del arreglo.
5) Si no es necesario intercambiar, el programa lo indica con un
mensaje.

d) Estado al Final de Cada Pasada: Después de completar cada pasada, se

imprime el estado del arreglo. Esto ayuda a visualizar qué números ya
están en su lugar final.

7. Método mostrarArreglo

a) Este método recorre el arreglo y muestra cada número separado por un

espacio.
b) El bucle for-each simplifica la iteración sobre los elementos del arreglo.
8. Mostrar el Resultado Final
a) Una vez que el método burbuja termina, se imprime el arreglo ordenado en
pantalla.
 EJECUTADO

Este programa implementa el método de ordenación burbuja para organizar un

conjunto de números proporcionados por el usuario. El proceso comienza
solicitando la cantidad de números a ordenar y, posteriormente, los valores
específicos. Los números ingresados se muestran inicialmente en el estado en
que fueron introducidos para dar una referencia antes de aplicar el algoritmo.

La ordenación se realiza comparando pares de números consecutivos en el

arreglo. Si un número es mayor que el siguiente, se realiza un intercambio para
colocarlos en el orden correcto. Este proceso se repite en varias "pasadas,"
reduciendo el rango de comparación en cada iteración, ya que los números más
grandes se van posicionando al final del arreglo en cada paso.
 PROPOSITOS/POSIBLES USOS

El programa implementa el método de ordenación por burbuja para organizar un

conjunto de números ingresados por el usuario en orden ascendente. Además,
muestra los pasos del proceso de ordenación para que el usuario entienda cómo
funciona el algoritmo.

a) Visualización del proceso de ordenación:

Gracias a su naturaleza paso a paso, es ideal para mostrar cómo se
ordenan los datos, lo que lo hace adecuado para tareas educativas o
herramientas de depuración en sistemas más grandes.
b) Sistemas con recursos limitados:
En entornos donde los recursos computacionales son muy limitados y la
cantidad de datos es pequeña, su implementación sencilla puede ser
ventajosa frente a algoritmos más complejos
10.-Gestión Quicksort
CLASE - GestionQuicksort
1. Introducción y Lectura de Entrada

a) Primero, creamos un objeto Scanner para leer los datos de la entrada

estándar (el teclado).
b) Luego le pedimos al usuario que ingrese la cantidad de elementos que
tendrá el arreglo (n).
c) Después, usamos un bucle for para que el usuario ingrese los valores del
arreglo uno por uno, almacenándolos en el arreglo array.
2. Imprimir el Arreglo Antes de Ordenar

a) Aquí simplemente mostramos el arreglo tal como fue ingresado antes de

aplicar el algoritmo de ordenamiento (Quicksort).
b) Para mostrar el arreglo, usamos el método imprimirArreglo(array)
3. Llamada al Método Quicksort

a) Llamamos al método quicksort, que es el encargado de ordenar el arreglo.

b) En este caso, le pasamos el arreglo array, el índice inicial (0) y el índice
final (n - 1), que corresponde a la última posición del arreglo.
4. El Método quicksort

a) Este es el núcleo del algoritmo Quicksort.

b) El método recibe como parámetros el arreglo, el índice de inicio (inicio) y el
índice de fin (fin).
c) Condición base: Si inicio es menor que fin, esto significa que el arreglo
tiene más de un elemento y debe ser ordenado.
d) Llamamos al método particion que reorganiza el arreglo y devuelve el
índice donde se colocó el pivote. Este índice divide el arreglo en dos partes.
e) Luego, se llama recursivamente a quicksort para ordenar la sublista a la
izquierda del pivote (inicio hasta pivoteIndex - 1) y la sublista a la derecha
(pivoteIndex + 1 hasta fin).
5. El Método particion
 a) El método particion es clave en Quicksort. Aquí se selecciona un pivote
(en este caso el último elemento del arreglo) y se reorganiza el arreglo de
manera que:

 Todos los elementos menores o iguales al pivote están antes que él.

 Todos los elementos mayores están después de él.

b) i es el índice de los elementos menores que el pivote, y se incrementa cada

vez que encontramos un número que es menor o igual al pivote.
c) Usamos un bucle for para recorrer el arreglo desde el índice inicio hasta el
índice fin - 1. Si un elemento es menor o igual al pivote, se realiza un
intercambio entre ese elemento y el elemento en el índice i + 1.
d) Después de recorrer el arreglo, colocamos el pivote en su posición correcta
(arr[i + 1]).
e) El método retorna el índice del pivote, que será utilizado para dividir el
arreglo en dos partes y continuar el proceso recursivo de ordenamiento.

6. Imprimir el Arreglo

Este es un simple método para imprimir los elementos del arreglo en una sola
línea. Utiliza un bucle for-each para recorrer el arreglo y mostrar sus elementos.
 EJECUTADO

El algoritmo Quicksort que hemos implementado tiene como objetivo ordenar un

conjunto de elementos (en este caso, números enteros) de menor a mayor. Este
algoritmo es muy eficiente y se usa ampliamente en la informática debido a su
rapidez en comparación con otros métodos de ordenamiento como el Método de
la burbuja o Inserción, especialmente cuando se trata de grandes cantidades de
datos.

El algoritmo utiliza un enfoque de divide y vencerás: selecciona un elemento

llamado pivote, divide el arreglo en dos partes (elementos menores que el pivote y
elementos mayores que el pivote), y luego aplica el mismo proceso
recursivamente a esas dos partes.

Aplicaciones en programación: Quicksort es una técnica fundamental en

sistemas informáticos y bases de datos cuando se necesita ordenar datos de
manera eficiente. Se utiliza en motores de búsqueda, ordenación de registros,
optimización de procesos y muchos otros escenarios que involucran grandes
volúmenes de datos.
11.-Gestión Shellsort
1. Declaración del método shellSort(int[] arr)

En primer lugar, creamos el método shellSort, que recibe como parámetro un

arreglo arr de enteros. Dentro de este método, declaramos la variable n para
almacenar la longitud del arreglo, es decir, el número de elementos que vamos a
ordenar.

2. Bucle exterior para manejar los gaps

Este es un bucle for que controla el gap (el tamaño del salto entre los elementos
que se comparan). Comenzamos con un gap igual a la mitad de la longitud del
arreglo n / 2, y luego reducimos el gap a la mitad en cada iteración (gap /= 2).

 Al principio, el gap es grande, lo que permite que los elementos estén más
dispersos.

 A medida que el gap disminuye, las comparaciones se hacen más precisas,

acercándose a lo que sería un ordenamiento de inserción normal.

3. Bucle interior para la inserción con gap

Dentro del bucle exterior, tenemos otro bucle for que recorre el arreglo desde el
índice gap hasta el final del arreglo (i < n). En cada iteración:

 temp: Guardamos el valor actual del arreglo arr[i] para poder insertarlo en la
posición correcta más adelante.
  j: Inicializamos una variable j que nos ayudará a recorrer el arreglo y mover
los elementos según sea necesario.

4. Desplazamiento de elementos según el gap

Aquí entra el proceso de desplazamiento de elementos. Usamos un bucle while

que sigue ejecutándose mientras:

 j >= gap: Asegura que no intentemos acceder a índices negativos.

 arr[j - gap] > temp: Compara el valor en la posición j - gap con el valor
guardado en temp. Si el valor de arr[j - gap] es mayor que temp, significa
que debe ser desplazado una posición hacia adelante.

Este proceso permite que los elementos más grandes "se deslicen" hacia la
derecha hasta encontrar su lugar correcto en el arreglo.

5. Colocación del valor en la posición correcta

Después de que el bucle while ha desplazado los elementos necesarios,

colocamos el valor guardado en temp en la posición j correcta dentro del arreglo.
6. Método printArray(int[] arr) para imprimir el arreglo

Este es un método auxiliar que simplemente recorre el arreglo arr y lo imprime en

la consola. Lo usamos después de cada paso de inserción en el algoritmo de
Shellsort para visualizar cómo cambia el arreglo durante el proceso de
ordenamiento.

7. Parte del main para la entrada de datos y ejecución

En el main, primero solicitamos al usuario el número de elementos del arreglo y
luego los elementos del arreglo. A continuación, imprimimos el arreglo antes de
ordenar, y luego llamamos al método shellSort para ordenar el arreglo,
imprimiendo el estado del arreglo durante cada paso de ordenamiento.
Finalmente, imprimimos el arreglo después de haber sido ordenado.

EJECUTADO

El propósito principal de Shellsort es ordenar arreglos de datos de forma eficiente,

especialmente en situaciones donde el uso de algoritmos más lentos como la
ordenación por inserción no es viable debido al tamaño del conjunto de datos. Su
ventaja radica en que, a diferencia de algoritmos de ordenación más simples,
realiza comparaciones a diferentes distancias (denominadas gaps) para hacer el
ordenamiento más rápido.

Usos o propósitos:

1. Optimización de tiempo de ordenamiento: Es útil cuando se necesita

mejorar el rendimiento de un algoritmo de ordenación en comparación con
algoritmos simples como el de burbuja o inserción.
2. Aplicaciones prácticas: Shellsort puede aplicarse en sistemas donde el
tamaño del arreglo no sea extremadamente grande, pero aún se requiere
un buen rendimiento. Se usa, por ejemplo, en aplicaciones como la
organización de datos en sistemas embebidos o bases de datos que no
manejan volúmenes de datos masivos.
12.-Gestion Radix
CLASE - RadixSort
1. Importación de Librerías

a) java.util.Scanner: Se utiliza para leer datos ingresados por el usuario

desde la consola.
b) javax.swing.*: Permite crear interfaces gráficas de usuario (GUI), como
ventanas y paneles.
c) java.awt.*: Se usa para manejar gráficos y elementos visuales, como
dibujos y colores.
2. Clase Principal: RadixSort12

La clase hereda de JPanel para aprovechar sus capacidades gráficas y mostrar

visualizaciones del algoritmo.

3. Atributos

a) array: Almacena los números que se están ordenando.

b) highlightedIndex: Indica el índice actual que se resalta en rojo durante la

visualización.
4. Constructor

a) Este constructor recibe el arreglo de números que se quiere ordenar.

Guarda el arreglo para trabajar con él en el resto de la clase.

5. Método updateArray

Propósito: Actualiza el arreglo mostrado en pantalla y resalta una barra

específica.

a) repaint(): Llama automáticamente al método paintComponent para

redibujar los elementos.
b) Thread.sleep(500): Pausa la ejecución por 500 ms para que los cambios
sean visibles.

6. Método paintComponent
Propósito: Dibuja las barras que representan los números.

a) getWidth() y getHeight(): Obtienen el ancho y alto del panel.

b) barWidth y barHeight: Calculan el tamaño de cada barra proporcional al
valor.
c) g.setColor: Cambia el color de la barra según si está resaltada o no.
d) g.fillRect: Dibuja las barras.
e) g.drawString: Escribe los valores de las barras encima de ellas.

7. Método getMaxValue

Propósito: Encuentra el valor máximo en el arreglo. Esto se usa para escalar las
alturas de las barras proporcionalmente.
8. Método countingSort

Propósito: Ordena los números según un dígito específico (unidad, decena, etc.).

a) count[]: Cuenta las ocurrencias de cada dígito.

b) Posición real: Calcula las posiciones finales de los números en el arreglo
ordenado.
c) updateArray: Visualiza cada paso del proceso.

9. Método radixSort

Propósito: Implementa el algoritmo RadixSort.

a) Divide el ordenamiento en pasos, procesando cada dígito (unidad,

decena, etc.).
b) Llama al método countingSort para cada paso.
10. Método main

Propósito: Configura el programa.

a) Entrada del usuario: Solicita los números a ordenar.

b) GUI: Crea la ventana (JFrame) donde se visualizarán los pasos del

algoritmo.

c) Hilo separado: Ejecuta el ordenamiento en un hilo aparte para no bloquear

la interfaz gráfica.
 EJECUTADO

Lo que estamos viendo es una representación gráfica del algoritmo Radix Sort, en
el cual se están ordenando los números ingresados por el usuario. Cada barra en
la visualización corresponde a un número del conjunto, y su altura es proporcional
a su valor.

En este punto del proceso, la barra en color rojo (que representa el número 12)
indica el elemento que está siendo evaluado o colocado en la posición correcta
durante esta iteración del algoritmo. Las demás barras en color azul corresponden
a los elementos ya procesados o que están en espera de ser ordenados.

La visualización no solo muestra el progreso del algoritmo paso a paso, sino que
también permite comprender de manera intuitiva cómo se realiza el ordenamiento
de los datos con base en los dígitos de menor a mayor significancia.

POSIBLES USOS:
Procesamiento de Archivos Grandes:
En aplicaciones como compresión de archivos o clasificación de grandes
volúmenes de registros, RadixSort es una opción eficiente porque evita las
comparaciones directas entre elementos, lo que lo hace ideal para datos con
valores numéricos de gran magnitud.

Gestión de Bases de Datos:

RadixSort puede ser útil para ordenar registros en bases de datos basadas en
campos numéricos, como identificaciones de usuarios, números de cuentas
bancarias o códigos postales. Esto es esencial para optimizar búsquedas y
clasificaciones en sistemas de almacenamiento masivo.
13.-Gestion intercalación
CLASE – GestionIntercalacion
1. Importaciones:

a) ArrayList: Utilizada para crear listas dinámicas que pueden cambiar de

tamaño. Es una estructura de datos que almacenará los números de
nuestras listas.
b) Collections: Proporciona métodos útiles para manipular colecciones. En
este caso, usamos Collections.sort() para ordenar las listas ingresadas por
el usuario.
c) Scanner: Esta clase se usa para leer datos desde la entrada estándar (es
decir, el teclado) y permitir al usuario ingresar los elementos de las listas.
2. Definición del Método main:

a) Declaración del método main:

 El punto de entrada al programa. Aquí es donde iniciamos la ejecución.

 Creamos un objeto Scanner para leer la entrada del usuario.

b) Declaración de las listas:

 lista1 y lista2: Dos listas donde el usuario ingresará los números

ordenados.

 listaIntercalada: Una lista donde se almacenarán los números

intercalados de las dos listas de entrada.
3. Lectura de las Listas por el Usuario:

a) Instrucción al usuario:

 Se le pide al usuario que ingrese los elementos para las dos listas (A y
B).

b) Llamada al método leerLista:

 Usamos el método leerLista para procesar la entrada del usuario y

almacenarla en las listas lista1 y lista2. Este método convierte las
entradas en enteros y asegura que las listas estén ordenadas.

4. Método leerLista

a) Entrada de datos:

El usuario introduce los números separados por espacios. Estos se almacenan

en un arreglo de cadenas (String[] elementos).

b) Conversión a enteros:

Usamos un ciclo for para recorrer cada elemento del arreglo de cadenas,
convertirlo a un número entero con Integer.parseInt(), y agregarlo a la lista
correspondiente.
 c) Ordenación:

Finalmente, usamos Collections.sort(lista) para ordenar la lista en caso de

que el usuario no haya ingresado los números en orden.

5. Intercalación de las Listas:

a) Proceso de intercalación:
 Usamos dos índices, i para lista1 y j para lista2, para recorrer ambas
listas.

 Comparamos los elementos en la posición actual de ambas listas.

o Si el elemento en lista1[i] es menor o igual que el de lista2[j], lo

añadimos a la lista intercalada.

o Si no, añadimos el elemento de lista2[j].

b) Mostrar proceso:

 Durante el proceso, el programa muestra qué número se está agregando a

la lista intercalada, indicando de qué lista proviene.
6. Añadir Elementos Restantes:

Añadir elementos sobrantes: Si alguna de las listas tiene elementos restantes

después de comparar, esos elementos se añaden directamente a la lista
intercalada.

7. Resultado Final:

Finalmente el programa imprime la lista intercalada completa y se cierra el objeto

Scanner para liberar los recursos.
 EJECUTADO

El programa ha intercalado correctamente dos listas desordenadas de números.

Primero, ordenó ambas listas y luego las combinó en una nueva lista manteniendo
el orden ascendente. El proceso consistió en añadir los elementos más pequeños
de ambas listas, primero los de la segunda lista y luego los de la primera. Al final,
se obtuvo una lista intercalada y ordenada: [22, 32, 41, 45, 51, 68, 70, 87, 90, 99,
123, 147, 258, 321, 456, 741, 789, 852, 897, 963]

POSIBLES USOS

a) Fusión de Listas o Archivos:

 Si tenemos varias listas o archivos con datos numéricos ordenados,

podemos fusionarlos en uno solo sin perder el orden. Este programa hace
precisamente eso.

b) Optimización de Procesos:

 En algoritmos que requieren trabajar con listas ordenadas, como en

algunos algoritmos de búsqueda o clasificación, fusionar listas ordenadas
de manera eficiente puede ahorrar tiempo y recursos.
14.-Gestion mezcla directa
CLASE – MezclaDirecta
1. Librerías importadas

a) Arrays: Esta librería se utiliza para trabajar con arreglos, proporcionando

métodos útiles como toString() para convertir un arreglo en una cadena
legible y copyOf() para crear una copia de un arreglo.
b) Scanner: Se utiliza para recibir entradas del usuario desde la consola, lo
que permite interactuar con el programa.

2. Definición de la clase MezclaDirecta14

a) Aquí se define la clase principal del programa. Esta es la clase que
ejecutará todo el código.
3. Método main

a) Scanner se inicializa para leer entradas del usuario. Se pide que el usuario
ingrese números hasta que ingrese 0, lo que terminará el proceso.

4. Ingreso de números al arreglo

a) arrayList es un arreglo de enteros con una capacidad inicial de 100

elementos. El número size lleva un seguimiento de la cantidad de números
ingresados.
 b) Ciclo while: Permite al usuario ingresar números repetidamente. Si el
número ingresado es 0, se rompe el ciclo y el programa termina de ingresar
números. Si no es 0, el número se guarda en el arreglo arrayList, y size se
incrementa para indicar la cantidad de elementos ingresados.

5. Creación de un arreglo de tamaño adecuado

a) Arrays.copyOf: Se crea un nuevo arreglo array de tamaño adecuado (solo

la cantidad de elementos ingresados, no 100). Luego, se imprime el arreglo
original con Arrays.toString().

6. Ordenamiento con el método MezclaSort

a) Se llama al método MezclaSort para ordenar el arreglo. El arreglo se

pasa junto con los índices de inicio (0) y final (array.length - 1).
b) Luego, se imprime el arreglo ordenado.
7. Método MezclaSort (Ordenamiento tipo "mezcla directa")

a) División recursiva: Este es el algoritmo de ordenamiento por mezcla

(Merge Sort). Divide el arreglo en dos mitades y llama recursivamente al
mismo método sobre cada mitad.
b) Después de dividir, fusiona las dos mitades ordenadas usando el método
mezcla.
8. Método mezcla (Fusionado de dos subarreglos ordenados)
 a) mezcla es el proceso donde se combinan dos subarreglos ordenados en
un solo arreglo ordenado. Se compara cada elemento de ambos arreglos
y se coloca en el arreglo final, hasta que se hayan agregado todos los
elementos de ambos arreglos.

9. Búsqueda Secuencial

a) Búsqueda secuencial: Este método recorre el arreglo y devuelve el

índice del primer elemento que coincide con el valor buscado. Si no se
encuentra el valor, devuelve -1.

10. Interacción final y cierre del scanner

a) Después de ordenar el arreglo, se le pide al usuario que ingrese un

número para buscar. Luego, el programa usa búsqueda secuencial para
buscar el valor en el arreglo ordenado y muestra el resultado.

b) Finalmente, el scanner se cierra para liberar recursos.

 EJECUTADO

El programa permite al usuario ingresar una serie de números, que se almacenan

en un arreglo hasta que el usuario ingresa el número 0 para finalizar. Luego, el
código utiliza el algoritmo de Mezcla Directa (Merge Sort) para ordenar los
números de menor a mayor. Este algoritmo divide el arreglo en subarreglos más
pequeños y los fusiona de manera ordenada. Después de ordenar, el programa
permite realizar una búsqueda secuencial para encontrar la posición de un número
específico en el arreglo ordenado.

Por ejemplo, si el usuario ingresa los números: [12, 67, 34, 89, 66, 43, 21, 54, 90,
58], el programa los ordenará y mostrará el arreglo ordenado: [12, 21, 34, 43, 54,
58, 66, 67, 89, 90]. Posteriormente, si se busca el número 54, el programa indicará
que se encuentra en la posición 4 del arreglo ordenado.

POSIBLES USOS:

Gestión de Listas de Datos: Este código es útil en escenarios donde se necesita

ordenar y buscar datos en una lista. Por ejemplo:

 Inventarios: En una tienda o almacén, los productos podrían ser

identificados por números (como códigos de barras o precios), y este
programa podría usarse para ordenar los productos por su código o precio.

 Listas de tareas: En aplicaciones de gestión de tareas, se podría usar para

ordenar tareas según su prioridad o fecha de vencimiento.
15.-Gestion mezcla natural
CLASE – MezclaNatural
1. Librerías

a) java.util.ArrayList y java.util.List: Nos permiten trabajar con listas

dinámicas en Java, útiles para almacenar números.
b) java.util.Scanner: Se utiliza para capturar entradas del usuario desde la
consola.
2. Clase principal

a) La clase se llama MezclaNatural15 porque el usuario pidió que tuviera ese

nombre.
b) Dentro del método main, organizamos el flujo principal del programa.

3. Captura de las listas del usuario

a) Solicitamos al usuario que introduzca dos listas de números.

b) Usamos el método leerLista para convertir los números introducidos en una
lista ordenada.
4. Mostrar las listas originales

Aquí simplemente imprimimos las listas ingresadas para que el usuario pueda
verificarlas.

5. Mezclar las listas y mostrar el procedimiento

a) Invocamos el método mezclarListas, que realiza la combinación ordenada

y muestra cada paso del proceso.
b) listaCombinada almacenará el resultado final.

6. Mostrar el resultado final

Una vez terminada la mezcla, imprimimos la lista combinada y ordenada.

7. Método leerLista

a) scanner.nextLine(): Captura toda la línea ingresada.

b) .split(" "): Divide los números separados por espacios en un arreglo de

cadenas.
 c) Bucle for: Recorre cada número en forma de cadena y lo convierte a entero
usando Integer.parseInt.

d) lista.add: Agrega cada número convertido a la lista.

e) Devuelve una lista de enteros.

8. Método mezclarListas

a) Creamos una nueva lista vacía listaCombinada donde almacenaremos el

resultado.
b) i y j son índices para recorrer lista1 y lista2.

9. Bucle principal: Mezclar elementos

a) Mientras haya elementos en ambas listas:

1. Comparamos los números actuales (lista1.get(i) y lista2.get(j)).

2. Añadimos el menor a listaCombinada y avanzamos el índice

correspondiente (i o j).

3. Imprimimos qué número fue añadido y el estado actual de la lista

combinada.
10. Añadir elementos restantes

a) Si una lista tiene números restantes, los añadimos directamente a

listaCombinada.
b) Mostramos qué número se añadió y el estado actual.

EJECUTADO

El programa implementa el algoritmo de mezcla natural, un método utilizado para

combinar dos listas de números, ordenarlas de forma eficiente y mostrar el
procedimiento paso a paso. Este algoritmo es una forma de ordenamiento por
fusión que sigue el principio de dividir y conquistar. El programa:

1. Toma entrada del usuario: Dos listas de números proporcionadas

manualmente.
 2. Realiza el proceso de mezcla: Compara los elementos de las dos listas y
los combina en una nueva lista respetando el orden de inserción.

3. Muestra el procedimiento: Detalla cada número que se añade a la lista

combinada, facilitando el aprendizaje y la comprensión del método.

4. Entrega el resultado final: Una lista combinada que mantiene el orden de

los elementos como fueron procesados.

POSIBLES USOS:

a) Procesamiento de registros:
En aplicaciones de tecnología, como sistemas que procesan logs o registros,
permite fusionar datos provenientes de diferentes fuentes, como servidores o
dispositivos.
b) Simulación de procesos empresariales:

Utilizarse como parte de un sistema simulado para integrar datos de clientes,

productos o cualquier otro flujo de información relevante.
 16.-Busqueda secuencial

CLASE - Busqueda secuencial

1. Declaración de la Clase y Método Principal

a) Aquí comienza el programa. La clase se llama BusquedaSecuencial16, y

dentro de ella está el método main, que es el punto de entrada.
 b) Este método contiene toda la lógica para interactuar con el usuario, llamar
al algoritmo y mostrar resultados.
2. Solicitar el Tamaño del Arreglo

a) Usamos Scanner para leer la entrada del usuario.

b) n almacena el tamaño del arreglo definido por el usuario.

3. Crear y Rellenar el Arreglo

a) Creamos un arreglo de tamaño n.

b) Con un bucle for, pedimos al usuario que introduzca cada elemento, que
almacenamos en el arreglo.

4. Solicitar el Número a Buscar

Aquí pedimos al usuario el número que desea buscar en el arreglo.

5. Llamar al Método de Búsqueda Secuencial

a) Usamos el método busquedaSecuencial para buscar el número en el

arreglo.
b) Este método devuelve la posición del número si lo encuentra, o -1 si no está
presente.

Cuerpo del Método: busquedaSecuencial

a) Recorremos el arreglo elemento por elemento con otro bucle for.

b) Si encontramos el número, devolvemos su posición.
c) Si llegamos al final sin encontrarlo, devolvemos -1.

6. Mostrar el Resultado

a) Usamos una condición if para verificar si la posición es válida.

b) Si el número está en el arreglo, mostramos su posición (sumando 1 porque
el índice inicia en 0).
c) Si no está, notificamos al usuario.
 EJECUTADO

Este programa implementa el algoritmo de búsqueda secuencial en Java. La

búsqueda secuencial es un algoritmo que permite encontrar un valor específico en
un arreglo o lista. El proceso consiste en recorrer cada elemento del arreglo uno
por uno, comparándolo con el valor que se desea encontrar. Si el valor es
encontrado, se devuelve la posición de dicho valor en el arreglo; si no es
encontrado, el algoritmo devuelve un valor especial que indica que no existe en el
arreglo.

POSIBLES USOS:

a) Búsqueda en listas pequeñas: Si se tiene un arreglo con pocos elementos

y no es necesario ordenar los datos, la búsqueda secuencial es adecuada
debido a su simplicidad y facilidad de implementación.
b) Verificación de elementos en datos no ordenados: En casos donde se
necesite verificar si un dato existe dentro de una lista o conjunto sin
importar el orden, este algoritmo puede servir.
17.-Busqueda binaria
1. Importación de Librerías

a) Scanner: Esta librería se usa para leer entradas del usuario desde la
consola, lo que nos permite obtener datos como el tamaño del arreglo, los
elementos del arreglo y el número que queremos buscar.
b) Arrays.sort(): Esta función de la librería Arrays se utiliza para ordenar el
arreglo de enteros de forma ascendente antes de aplicar la búsqueda
binaria.

2. Definición de la Función de Búsqueda Binaria

a) Parámetros:

 arreglo: un arreglo de enteros ordenado en el que buscamos un

número.

 objetivo: el número que queremos encontrar en el arreglo.

b) Variables:

 izquierda: apunta al índice del primer elemento del arreglo.

 derecha: apunta al índice del último elemento del arreglo.

 medio: calcula el índice medio entre izquierda y derecha en cada

iteración.

c) Lógica:

1. El algoritmo comienza con los índices izquierda y derecha.

2. En cada iteración, calcula el índice medio, que es el promedio de

izquierda y derecha.

3. Si el número en la posición medio es igual al objetivo, devuelve el

índice medio, indicando que se ha encontrado el número.

4. Si el número en medio es menor que el objetivo, eso significa que el

objetivo está en la mitad derecha del arreglo, por lo que ajustamos
izquierda para que apunte a medio + 1.

5. Si el número en medio es mayor que el objetivo, eso significa que el

objetivo está en la mitad izquierda del arreglo, por lo que ajustamos
derecha para que apunte a medio - 1.

6. Si no se encuentra el número después de varias iteraciones, el

método devuelve -1, indicando que el número no está en el arreglo.
3. Método main para Ejecutar el Programa

Función main:

1. Scanner para Entrada del Usuario: El programa solicita al usuario el

tamaño del arreglo n, luego le pide que ingrese los elementos del arreglo.

2. Ordenar el Arreglo: Después de que el usuario ingrese los elementos, el

arreglo se ordena utilizando Arrays.sort(arreglo). La búsqueda binaria solo
funciona correctamente en arreglos ordenados.

3. Buscar el Número: El usuario introduce el número que desea buscar. Este

número se pasa como argumento a la función de búsqueda binaria.

4. Resultado: Si el número es encontrado, se muestra su índice. Si no se

encuentra, se muestra un mensaje indicando que no está presente en el
arreglo.

5. Cierre del Scanner: Finalmente, se cierra el objeto Scanner para liberar

los recursos utilizados
 EJECUTADO

En este programa, estamos implementando dos algoritmos de búsqueda en un

arreglo: búsqueda secuencial y búsqueda binaria. La búsqueda secuencial recorre
todos los elementos del arreglo uno por uno, mientras que la búsqueda binaria
realiza una búsqueda más eficiente en un arreglo ordenado, dividiendo el espacio
de búsqueda a la mitad en cada paso.

POSIBLES USOS:

a) Búsqueda de un número en bases de datos no ordenadas (para búsqueda

secuencial).
b) Optimización de búsquedas en grandes volúmenes de datos ordenados,
como registros de usuarios, inventarios o cualquier conjunto de datos que
requiera encontrar elementos de manera rápida.
c) Aplicaciones de búsqueda en juegos: Localización de elementos o
personajes en una lista o arreglo de objetos.
18.-Busqueda por funciones de hash
1. Estructura del Código

Clase Node: Esta clase define un nodo de la lista enlazada. Cada nodo contiene
dos elementos:

a) data: el valor que queremos almacenar (en este caso, un número entero).

b) next: una referencia al siguiente nodo de la lista. Al principio, esta

referencia es null, porque no hay otro nodo al que apuntar.

Clase LinkedList: En la clase LinkedList, manejamos dos operaciones

importantes:

a) insert(int data): Esta función se encarga de insertar un nuevo nodo al

principio de la lista enlazada. Si hay varios elementos que colisionan en la
misma posición de la tabla de hash, los insertamos uno tras otro en la lista.

b) search(int data): Esta función busca un elemento dentro de la lista

enlazada. Si el valor que buscamos está en algún nodo, la función devuelve
true; si no, devuelve false.
2. Función Hash

La función hash es crucial en este tipo de estructuras de datos. Es la encargada

de asignar cada elemento a una posición específica en la tabla. En el código, la
función hash es muy sencilla y se calcula utilizando el módulo del valor de la clave
con el tamaño de la tabla

Esto nos da un índice entre 0 y SIZE-1, lo que nos asegura que los elementos
serán distribuidos dentro del arreglo de manera eficiente.

3. Insertar y Buscar Elementos en la Tabla de Hash

La clase HashSearch18 contiene dos operaciones principales:

a) insert(int key): Esta función usa la función hash para determinar el índice
en la tabla donde debemos insertar el elemento. Si ya existe una lista
enlazada en esa posición, simplemente insertamos el nuevo valor al
principio de la lista; si no, creamos una nueva lista enlazada en esa
posición.
 b) search(int key): Similar a insert, esta función calcula el índice de la tabla
usando la función hash. Luego, busca el elemento dentro de la lista
enlazada correspondiente a esa posición.

4. Interfaz de Usuario y Menú

Finalmente, tenemos un pequeño menú en el método main que permite al usuario

interactuar con el programa.
 EJECUTADO

En este programa, estamos implementando una tabla de hash con manejo de

colisiones mediante listas enlazadas. Una tabla de hash es una estructura de
datos fundamental en informática que nos permite almacenar y buscar elementos
de manera eficiente, aprovechando una función hash que determina la posición en
la que se almacenan los elementos dentro de un arreglo.

a) Insertar elementos: Cuando insertamos un número en la tabla de hash,

primero calculamos su índice usando una función hash que toma el valor
del número y le aplica el operador módulo con el tamaño de la tabla. Si hay
una colisión, es decir, si otro número ya está almacenado en esa posición,
 los elementos se gestionan mediante una lista enlazada en la misma
posición.
b) Buscar elementos: Cuando buscamos un número, calculamos su índice
con la misma función hash y luego recorremos la lista enlazada en esa
posición para encontrar el número deseado.

POSIBLES USOS:

1. Gestión de bases de datos: En aplicaciones de bases de datos, donde se

almacenan grandes cantidades de información y se requiere buscar
rápidamente registros específicos.
2. Sistemas de cache: En aplicaciones donde se necesita almacenar en
caché resultados de consultas o cálculos costosos, de manera que se
pueda acceder a ellos rápidamente.