Programa Java para verificar si una string es un Palindrome

Se dice que una cuerda es un palíndromo si es igual si comenzamos a leerla de izquierda a derecha o de derecha a izquierda. Entonces, consideremos una string » str» , ahora la tarea es solo descubrir que su string inversa es la misma. 

Ejemplo:

Input : str = "abba" 
Output: Yes

Input : str = "geeks"
Output: No  

Enfoque ingenuo: al invertir la string dada y comparar
podemos verificar si la string dada es un palíndromo comparando la string original con su versión invertida. 
A continuación se muestra la implementación del enfoque anterior:

/*package whatever //do not write package name here */
 
import java.io.*;
 
class GFG {
    public static boolean isPalindrome(String str)
    {
        // Initializing an empty string to store the reverse
        // of the original str
        String rev = "";
 
        // Initializing a new boolean variable for the
        // answer
        boolean ans = false;
 
        for (int i = str.length() - 1; i >= 0; i--) {
            rev = rev + str.charAt(i);
        }
 
        // Checking if both the strings are equal
        if (str.equals(rev)) {
            ans = true;
        }
        return ans;
    }
    public static void main(String[] args)
    {
        // Input string
        String str = "geeks";
 
        // Convert the string to lowercase
        str = str.toLowerCase();
        boolean A = isPalindrome(str);
        System.out.println(A);
    }
}

false

En el ejemplo anterior, si escribimos ABba en lugar de abba , también deberíamos obtener el resultado como yes . Entonces, debemos cambiar el caso de la string a minúsculas o mayúsculas antes de buscar un palíndromo. Si no hacemos esto, obtendremos resultados inesperados. Esto se debe a que el compilador verifica los caracteres en función de su valor ASCII y el valor ASCII de A no es lo mismo que un . 

Enfoque: nuestro enfoque será que primero convertiremos la string a minúsculas. Luego, tomaremos dos punteros i apuntando al comienzo de la string y j apuntando al final de la string. Continúe incrementando i y disminuyendo j mientras i < j y en cada paso verifique si los caracteres en estos punteros son iguales o no. Si no, entonces la cuerda no es un palíndromo, de lo contrario lo es.

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

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

Enfoque recursivo: El enfoque es muy simple. Al igual que en el enfoque de dos punteros, comprobaremos el primer y el último valor de la string, pero esta vez será a través de la recursividad.

1. Tomaremos dos punteros i apuntando al comienzo de la string y j apuntando al final de la string. 
2. Siga incrementando i y decrementando j mientras i < j y en cada paso 
3. Compruebe si los caracteres en estos punteros son iguales o no. Estamos haciendo esto a través de la recursividad – (i+1, j-1
4. Si todos los caracteres son iguales en el i-ésimo y j-ésimo índice hasta que se cumple la condición i>=j, imprime verdadero; de lo contrario, es 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.*;
 
class GFG {
    public static boolean isPalindrome(int i, int j,
                                       String A)
    {
        // comparing the two pointers
        if (i >= j) {
            return true;
        }
 
        // comparing the characters on those pointers
        if (A.charAt(i) != A.charAt(j)) {
            return false;
        }
 
        // checking everything again recursively
        return isPalindrome(i + 1, j - 1, A);
    }
 
    public static boolean isPalindrome(String A)
    {
        return isPalindrome(0, A.length() - 1, A);
    }
 
    public static void main(String[] args)
    {
        // Input string
        String A = "geeks";
 
        // Convert the string to lowercase
        A = A.toLowerCase();
        boolean str = isPalindrome(A);
        System.out.println(str);
    }
}

false