Voorbeeld 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 

De complexiteit van de bovenstaande methode:

Tijdcomplexiteit: De tijdscomplexiteit van de gegeven code is O(n), waarbij n de lengte van de invoerreeks is. Dit komt doordat de while-lus door de helft van de string loopt om te controleren of het een palindroom is. Omdat we slechts de helft van de string controleren, is het aantal iteraties evenredig met n/2, wat O(n) is.

Ruimtecomplexiteit: De ruimtecomplexiteit van de code is O(1), omdat de code slechts een constante hoeveelheid extra ruimte gebruikt die onafhankelijk is van de invoergrootte. De enige variabelen die in de code worden gebruikt, zijn i, j en str, die elk een constante hoeveelheid ruimte in beslag nemen. Er wordt geen extra ruimte in de code gecreëerd.

Voorbeeld 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 

De complexiteit van de bovenstaande methode:

Tijdcomplexiteit: De tijdscomplexiteit van de gegeven code is O(n), waarbij n de lengte van de invoerreeks is. Dit komt omdat de while-lus in de `isPalindrome`-methode de helft van de string doorloopt om te controleren of het een palindroom is. Omdat we slechts de helft van de string controleren, is het aantal iteraties evenredig met n/2, wat O(n) is.

Ruimtecomplexiteit: De ruimtecomplexiteit van de code is O(1), omdat de code slechts een constante hoeveelheid extra ruimte gebruikt die onafhankelijk is van de invoergrootte. De enige variabelen die in de code worden gebruikt, zijn i, j, str en str2, die elk een constante hoeveelheid ruimte in beslag nemen. Er wordt geen extra ruimte in de code gecreëerd.

3. Recursieve benadering voor P alindrome-programma op Java

De aanpak is heel eenvoudig. Net als bij de tweepuntsbenadering zullen we de eerste en de laatste waarde van de string controleren, maar deze keer gebeurt dit via recursie.

• We nemen twee verwijzingen, i die naar het begin van de string wijzen en j die naar het einde van de string wijst.
• Blijf i verhogen en j verlagen terwijl i
• Controleer of de tekens bij deze verwijzingen hetzelfde zijn of niet. We doen dit door middel van recursie – (i+1, j-1
• Als alle tekens hetzelfde zijn in de i-de en j-de index totdat aan de i>=j-voorwaarde wordt voldaan, wordt waar anders onwaar afgedrukt.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

// 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) { retourneer waar; } // het vergelijken van de karakters op deze wijzers if (A.charAt(i) != A.charAt(j)) { return false; } // alles opnieuw recursief controleren return isPalindrome(i + 1, j - 1, A); } public static boolean isPalindrome(String A) { return isPalindrome(0, A.length() - 1, A); } // hoofdfunctie public static void main(String[] args) {// Invoerreeks String A = 'geeks'; // Converteer de tekenreeks naar kleine letters A = A.toLowerCase(); boolean str = isPalindroom(A); Systeem.out.println(str); } } 

false 

De complexiteit van de bovenstaande methode:

Tijdcomplexiteit: De tijdscomplexiteit van de gegeven code is O(n), waarbij n de lengte van de invoerreeks is. Dit komt doordat de functie 'isPalindrome' zichzelf recursief aanroept voor de karakters op posities (i+1, j-1) totdat de pointers i en j elkaar kruisen of de karakters op de pointers niet gelijk zijn. Omdat we elk teken in de string precies één keer vergelijken, is de tijdscomplexiteit O(n).

Ruimtecomplexiteit: De ruimtecomplexiteit van de code is O(n), waarbij n de lengte van de invoerreeks is. Dit komt omdat elke recursieve aanroep een nieuw stapelframe creëert waarin de huidige waarden van de functieparameters en lokale variabelen worden opgeslagen. In het ergste geval kan de functieaanroepstapel zo groot worden als n/2 (wanneer de invoerreeks een palindroom is), dus de ruimtecomplexiteit is O(n).

4. StringBuilder-aanpak gebruiken in Java

Bij deze aanpak

• Eerst nemen we de String-invoer van de gebruiker.
• Vervolgens maken we het Stringbuilder-object str1″en slaan de waarde van String daarin op.
• De reverse()-methode in Stringbuider geeft ons de omgekeerde String. Ee sla die omgekeerde String op in str1.
• Met behulp van de equals() methode vergelijken we de waarden van de string, met behulp van if en else condition check of de stringwaarde vergelijkbaar is of niet.

Hieronder vindt u de implementatie van de bovenstaande aanpak:

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 

De complexiteit van de bovenstaande code:

Tijdcomplexiteit: De tijdscomplexiteit van de code is O(n), waarbij n wederom de lengte is van de invoerstring str. De belangrijkste factor die bijdraagt ​​aan deze tijdscomplexiteit is het omkeren van de string met behulp van str1.reverse(). Het op deze manier omkeren van een string heeft een tijdscomplexiteit van O(n), waarbij n de lengte van de string is. Andere bewerkingen in de code, zoals het lezen van de invoer en het vergelijken van de tekenreeksen, zijn bewerkingen met een constante tijd en hebben geen significante invloed op de algehele tijdscomplexiteit.

Ruimtecomplexiteit: De ruimtecomplexiteit van de gegeven Java-code is O(n), waarbij n de lengte is van de invoerstring str. Dit komt omdat de code een StringBuilder gebruikt om een ​​omgekeerde kopie van de invoerreeks op te slaan, en de benodigde ruimte voor de StringBuilder evenredig is aan de lengte van de invoerreeks.

Referentie

Voor meer informatie over Palindroom verwijzen wij u naar Programma voor String Palindroom .