Ejercicio Java
En este ejercicio, crearás un programa en Java que implemente varias buenas prácticas de programación y optimización de código. El objetivo es escribir un código limpio y eficiente, aplicando técnicas como la reducción de complejidad, la mejora de la legibilidad y la optimización de algoritmos. Trabajarás con estructuras de datos y algoritmos comunes, asegurándote de que tu código sea fácil de mantener, entender y ejecutar de manera eficiente.
Instrucciones:
- Escribe un programa que resuelva un problema común (por ejemplo, ordenar una lista de elementos) utilizando un algoritmo eficiente.
- Aplica técnicas de optimización, como la mejora en el uso de memoria y el tiempo de ejecución.
- Refactoriza el código asegurándote de que sea legible, modular y bien comentado.
- Realiza pruebas de rendimiento para comparar el rendimiento de tu implementación antes y después de la optimización.
Este ejercicio te ayudará a mejorar tus habilidades en la escritura de código optimizado y limpio, siguiendo las mejores prácticas de desarrollo para obtener aplicaciones Java de alto rendimiento.
Ver código de ejemplo
import java.util.Arrays;
public class OrdenacionOptimizada {
// Método para realizar el algoritmo QuickSort
public static void quickSort(int[] arreglo, int bajo, int alto) {
if (bajo < alto) {
int indicePivote = particionar(arreglo, bajo, alto);
quickSort(arreglo, bajo, indicePivote - 1); // Ordenar la parte izquierda
quickSort(arreglo, indicePivote + 1, alto); // Ordenar la parte derecha
}
}
// Método para particionar el arreglo
public static int particionar(int[] arreglo, int bajo, int alto) {
int pivote = arreglo[alto]; // El último elemento es el pivote
int i = (bajo - 1);
for (int j = bajo; j < alto; j++) {
// Si el elemento actual es menor que el pivote
if (arreglo[j] < pivote) {
i++;
// Intercambiar los elementos
int temp = arreglo[i];
arreglo[i] = arreglo[j];
arreglo[j] = temp;
}
}
// Intercambiar el pivote con el elemento en la posición correcta
int temp = arreglo[i + 1];
arreglo[i + 1] = arreglo[alto];
arreglo[alto] = temp;
return i + 1;
}
// Método principal para ejecutar el programa
public static void main(String[] args) {
int[] numeros = { 12, 11, 13, 5, 6, 7 };
System.out.println("Arreglo original: " + Arrays.toString(numeros));
// Llamada al algoritmo de ordenación optimizado
long inicio = System.nanoTime(); // Medir el tiempo de inicio
quickSort(numeros, 0, numeros.length - 1);
long fin = System.nanoTime(); // Medir el tiempo de fin
// Mostrar el arreglo ordenado
System.out.println("Arreglo ordenado: " + Arrays.toString(numeros));
// Mostrar el tiempo de ejecución
System.out.println("Tiempo de ejecución (en nanosegundos): " + (fin - inicio));
}
}
Salida:
Arreglo original: [12, 11, 13, 5, 6, 7]
Arreglo ordenado: [5, 6, 7, 11, 12, 13]
Tiempo de ejecución (en nanosegundos): 21423
Este programa implementa el algoritmo **QuickSort**, una de las mejores soluciones para ordenar arreglos debido a su eficiencia en términos de tiempo de ejecución en la mayoría de los casos. Al realizar la optimización, el código es más eficiente tanto en memoria como en tiempo, y se refactoriza para ser modular y fácil de entender.