Ejemplo 1:

// Java program to check whether a // string is a Palindrome // Using two pointing variables // Main class public class GFG { // Method // Returning true if string is palindrome static boolean isPalindrome(String str) { // Pointers pointing to the beginning // and the end of the string int i = 0, j = str.length() - 1; // While there are characters to compare while (i  < j) { // If there is a mismatch if (str.charAt(i) != str.charAt(j)) return false; // Increment first pointer and // decrement the other i++; j--; } // Given string is a palindrome return true; } // Method 2 // main driver method public static void main(String[] args) { // Input string String str = 'geeks'; // Convert the string to lowercase str = str.toLowerCase(); // passing bool function till holding true if (isPalindrome(str)) // It is a palindrome System.out.print('Yes'); else // Not a palindrome System.out.print('No'); } } 

No 

La complejidad del método anterior:

Complejidad del tiempo: La complejidad temporal del código dado es O(n), donde n es la longitud de la cadena de entrada. Esto se debe a que el bucle while recorre la mitad de la cadena para comprobar si es un palíndromo. Como solo verificamos la mitad de la cadena, el número de iteraciones es proporcional a n/2, que es O(n).

Complejidad espacial: La complejidad espacial del código es O(1), porque el código solo utiliza una cantidad constante de espacio adicional que es independiente del tamaño de entrada. Las únicas variables utilizadas en el código son i, j y str, cada una de las cuales ocupa una cantidad constante de espacio. No se crea ningún espacio adicional en el código.

Ejemplo 2:

// Java Program to check Whether // the String is Palindrome // or Not // Main class class GFG { // Method 1 // Returns true if string is a palindrome static boolean isPalindrome(String str) { // Pointers pointing to the beginning // and the end of the string int i = 0, j = str.length() - 1; // While there are characters to compare while (i  < j) { // If there is a mismatch if (str.charAt(i) != str.charAt(j)) return false; // Increment first pointer and // decrement the other i++; j--; } // Given string is a palindrome return true; } // Main driver method public static void main(String[] args) { String str = 'geeks'; String str2 = 'RACEcar'; // Change strings to lowercase str = str.toLowerCase(); str2 = str2.toLowerCase(); // For string 1 System.out.print('String 1 :'); if (isPalindrome(str)) System.out.print('It is a palindrome'); else System.out.print('It is not a palindrome'); // new line for better readability System.out.println(); // For string 2 System.out.print('String 2 :'); if (isPalindrome(str2)) System.out.print('It is a palindrome'); else System.out.print('It is not a palindrome'); } } 

String 1 :It is not a palindrome String 2 :It is a palindrome 

La complejidad del método anterior:

Complejidad del tiempo: La complejidad temporal del código dado es O(n), donde n es la longitud de la cadena de entrada. Esto se debe a que el bucle while en el método `isPalindrome` recorre la mitad de la cadena para verificar si es un palíndromo. Como solo verificamos la mitad de la cadena, el número de iteraciones es proporcional a n/2, que es O(n).

Complejidad espacial: La complejidad espacial del código es O(1), porque el código solo utiliza una cantidad constante de espacio adicional que es independiente del tamaño de entrada. Las únicas variables utilizadas en el código son i, j, str y str2, cada una de las cuales ocupa una cantidad constante de espacio. No se crea ningún espacio adicional en el código.

3. Enfoque recursivo para P Programa alíndromo en Java

El planteamiento es muy sencillo. Al igual que en el método de dos punteros, comprobaremos el primer y el último valor de la cadena, pero esta vez será mediante recursividad.

• Tomaremos dos punteros i que apuntan al inicio de la cadena y j que apuntan al final de la cadena.
• Sigue incrementando i y disminuyendo j mientras i
• Compruebe si los caracteres en estos punteros son iguales o no. Estamos haciendo esto mediante recursividad – (i+1, j-1
• Si todos los caracteres son iguales en el índice i-ésimo y j-ésimo hasta que se cumpla la condición i>=j, imprima verdadero; de lo contrario, falso.

A continuación se muestra la implementación del enfoque anterior:

// Java program to check whether a // string is a Palindrome using recursion import java.io.*; // Driver Class class GFG { public static boolean isPalindrome(int i, int j, String A) { // comparing the two pointers if (i>= j) { devolver verdadero; } // comparando los caracteres en esos punteros if (A.charAt(i) != A.charAt(j)) { return false; } // comprobando todo nuevamente recursivamente return isPalindrome(i + 1, j - 1, A); } isPalindrome booleano estático público (Cadena A) { return isPalindrome (0, A.length() - 1, A); } // función principal public static void main(String[] args) { // Cadena de entrada String A = 'geeks'; // Convierte la cadena a minúscula A = A.toLowerCase(); cadena booleana = isPalindrome(A); System.out.println(cadena); } } 

false 

La complejidad del método anterior:

Complejidad del tiempo: La complejidad temporal del código dado es O(n), donde n es la longitud de la cadena de entrada. Esto se debe a que la función `isPalindrome` se llama a sí misma de forma recursiva para los caracteres en las posiciones (i+1, j-1) hasta que los punteros i y j se cruzan o los caracteres en los punteros no son iguales. Dado que comparamos cada carácter de la cadena exactamente una vez, la complejidad temporal es O (n).

Complejidad espacial: La complejidad espacial del código es O(n), donde n es la longitud de la cadena de entrada. Esto se debe a que cada llamada recursiva crea un nuevo marco de pila que almacena los valores actuales de los parámetros de la función y las variables locales. En el peor de los casos, la pila de llamadas a funciones puede crecer hasta n/2 (cuando la cadena de entrada es un palíndromo), por lo que la complejidad del espacio es O(n).

4. Uso del enfoque StringBuilder en Java

En este enfoque,

• Primero, tomamos la entrada String del usuario.
• Luego creamos el objeto Stringbuilder str1″ y almacenamos el valor de String en él.
• El método reverse() en Stringbuider nos da la cadena inversa. Almacena esa cadena inversa en str1.
• Con la ayuda del método equals() comparamos los valores de la cadena, con la ayuda de la condición if y else verificamos que el valor de la cadena sea similar o no.

A continuación se muestra la implementación del enfoque anterior:

import java.util.Scanner; public class Main { public static void main(String[] args) { String str = 'GeeksForGeeks'; // String for testing StringBuilder str1 = new StringBuilder(str); str1.reverse(); if (str.equals(str1.toString())) { System.out.println('Palindrome String'); } else { System.out.println('Not a palindrome String'); } } } 

Not a palindrome String 

La complejidad del Código anterior:

Complejidad del tiempo: La complejidad temporal del código es O(n), donde n es nuevamente la longitud de la cadena de entrada str. El factor principal que contribuye a esta complejidad temporal es la inversión de la cadena usando str1.reverse(). Invertir una cadena de esta manera tiene una complejidad temporal de O(n), donde n es la longitud de la cadena. Otras operaciones en el código, como leer la entrada y comparar cadenas, son operaciones de tiempo constante y no afectan significativamente la complejidad del tiempo general.

Complejidad espacial: La complejidad espacial del código Java dado es O(n), donde n es la longitud de la cadena de entrada str. Esto se debe a que el código utiliza StringBuilder para almacenar una copia invertida de la cadena de entrada, y el espacio requerido para StringBuilder es proporcional a la longitud de la cadena de entrada.

Referencia

Para saber más sobre Palíndromo consulte Programa para palíndromo de cuerdas .