Estructuras de Datos y Algoritmos en Java: Pilas, Colas, Cadenas y Palíndromos con Ejemplos Prácticos
Ejercicios de Programación en Java: Cadenas, Recursividad y Estructuras de Datos
1. Contador de consonantes de una palabra
El siguiente programa solicita una palabra al usuario y cuenta el número de consonantes que contiene. Para ello utiliza los métodos length, Character.isLetter, charAt y toLowerCase.
public class ConsonantesPalabra {
public static void main(String args[]) {
// contador de consonantes
// métodos a usar: length, Character.isLetter, charAt, toLowerCase
Scanner sc = new Scanner(System.in);
System.out.println("Introduzca una palabra...");
String palabraIntroducida = sc.next();
int contadorConsonantes = 0;
for (int i = 0; i < palabraIntroducida.length(); i++) {
if (Character.isLetter(palabraIntroducida.charAt(i))
&& !esVocal(palabraIntroducida.charAt(i))) {
contadorConsonantes++;
System.out.print(palabraIntroducida.charAt(i) + " ");
}
}
System.out.println("\nNúmero de consonantes de " + palabraIntroducida
+ ": " + contadorConsonantes);
}
public static boolean esVocal(char c) {
c = Character.toLowerCase(c);
return (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');
}
}2. Invertir una cadena
Este programa invierte la cadena introducida recorriéndola desde el último carácter hasta el primero.
public class InvertirCadena {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Introduce una cadena...");
String cadena = sc.next();
String cadenaInvertida = "";
for (int i = cadena.length() - 1; i >= 0; i--) {
cadenaInvertida = cadenaInvertida + cadena.charAt(i);
}
System.out.println(cadenaInvertida);
}
}3. Comprobación de palíndromos
Un palíndromo es una palabra o frase que se lee igual de izquierda a derecha que de derecha a izquierda. El programa elimina los espacios y compara los caracteres desde los extremos hacia el centro, usando dos índices: inc y des.
public class Palindromo {
public static void main(String[] args) {
String palabra = "ana ana";
palabra = palabra.replace(" ", "");
int inc = 0;
int des = palabra.length() - 1;
boolean esPalindromo = true;
while ((inc < des) && (esPalindromo)) {
if (palabra.charAt(inc) == palabra.charAt(des)) {
inc++;
des--;
} else {
esPalindromo = false;
}
}
if (esPalindromo) {
System.out.println(palabra + " es un palíndromo");
} else {
System.out.println(palabra + " no es un palíndromo");
}
}
}4. Inversión de cadenas con recursividad
En este ejemplo se comparan dos formas de invertir una cadena: mediante StringBuffer.reverse() y mediante una función recursiva que llama a sí misma con la subcadena restante.
public class ReverseRecursivo {
// El parámetro args se trata como una matriz de cadenas
// igual que en la sintaxis normal
public static void main(String... args) {
String palabra = "avión";
StringBuffer sb = new StringBuffer(palabra);
System.out.println(sb.reverse());
System.out.println(reverse(palabra));
}
public static String reverse(String palabra) {
if (palabra.length() == 1) {
return palabra;
} else {
return reverse(palabra.substring(1)) + palabra.charAt(0);
}
}
}5. Cola dinámica (FIFO)
Una cola sigue el principio FIFO (First In, First Out): el primer elemento en entrar es el primero en salir. Esta implementación utiliza nodos enlazados.
// FIFO
// EL PRIMERO EN ENTRAR, ES EL PRIMERO EN SALIR
public class ColaDinamica {
Nodo inicio;
Nodo fin;
public ColaDinamica() {
inicio = null;
fin = null;
}
public boolean colaVacia() {
return (inicio == null);
}
public void meter(Object objeto) {
Nodo nuevo = new Nodo(objeto, null);
if (colaVacia()) {
inicio = nuevo;
fin = nuevo;
} else {
fin.setEnlace(nuevo);
fin = nuevo;
}
}
public Object sacar() {
if (colaVacia()) {
System.out.println("Cola vacía");
return null;
}
Object aux = inicio.getInfo();
inicio = inicio.getEnlace();
return aux;
}
}6. Cola estática
La cola estática se implementa con un array de tamaño fijo. Los índices inicio y fin marcan la posición de extracción e inserción respectivamente.
public class ColaEstatica {
char cola[];
int inicio; // posición donde eliminamos
int fin; // posición donde insertamos
final int tamMax;
public ColaEstatica() {
inicio = 0;
fin = 0;
tamMax = 'z' - 'a' + 1;
cola = new char[tamMax];
}
public boolean colaVacia() {
return (inicio == fin);
}
public boolean colaLlena() {
return (fin == tamMax);
}
public void meter(char letra) {
if (colaLlena()) {
System.out.println("Cola llena");
} else {
cola[fin] = letra;
fin++;
}
}
public char sacar() {
if (colaVacia()) {
System.out.println("Cola vacía");
return 0;
} else {
inicio++;
return cola[inicio - 1];
}
}
public void rellenar() {
for (char letra = 'a'; letra <= 'z'; letra++) {
meter(letra);
}
}
public void vaciar() {
while (!colaVacia()) {
sacar();
}
}
}7. Clase Nodo
La clase Nodo es la base de las estructuras enlazadas. Almacena una información genérica (info) y una referencia al siguiente nodo (enlace).
public class Nodo {
Object info;
Nodo enlace;
public Nodo(Object info, Nodo enlace) {
this.info = info;
this.enlace = enlace;
}
public int compareTo(Object objeto) {
return ((String) this.info).compareTo((String) ((Nodo) objeto).info);
}
public Object getInfo() {
return info;
}
public void setInfo(Object info) {
this.info = info;
}
public Nodo getEnlace() {
return enlace;
}
public void setEnlace(Nodo enlace) {
this.enlace = enlace;
}
}8. Pila dinámica (LIFO)
Una pila sigue el principio LIFO (Last In, First Out): el último elemento en entrar es el primero en salir. La cima de la pila es el único punto de acceso.
// LIFO
// EL ÚLTIMO EN ENTRAR, ES EL PRIMERO EN SALIR
public class PilaDinamica {
Nodo cima;
public PilaDinamica() {
cima = null;
}
public boolean pilaVacia() {
return (cima == null);
}
public void meter(Object objeto) {
Nodo nuevo = new Nodo(objeto, cima);
cima = nuevo;
}
public Object sacar() {
if (pilaVacia()) {
System.out.println("Pila vacía");
return null;
}
Object aux = cima.getInfo();
cima = cima.getEnlace();
return aux;
}
}