Exempel 1:

char till int java

// 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>

Komplexiteten av ovanstående metod:

Tidskomplexitet: Tidskomplexiteten för den givna koden är O(n), där n är längden på inmatningssträngen. Detta beror på att while-slingan itererar genom halva strängen för att kontrollera om det är ett palindrom. Eftersom vi bara kontrollerar hälften av strängen är antalet iterationer proportionellt mot n/2, vilket är O(n).

Utrymmes komplexitet: Kodens utrymmeskomplexitet är O(1), eftersom koden bara använder en konstant mängd extra utrymme som är oberoende av indatastorleken. De enda variablerna som används i koden är i, j och str, som var och en tar upp en konstant mängd utrymme. Inget extra utrymme skapas i koden.

Exempel 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>

Komplexiteten av ovanstående metod:

Tidskomplexitet: Tidskomplexiteten för den givna koden är O(n), där n är längden på inmatningssträngen. Detta beror på att while-slingan i `isPalindrome`-metoden itererar genom halva strängen för att kontrollera om det är ett palindrom. Eftersom vi bara kontrollerar hälften av strängen är antalet iterationer proportionellt mot n/2, vilket är O(n).

Utrymmes komplexitet: Kodens utrymmeskomplexitet är O(1), eftersom koden bara använder en konstant mängd extra utrymme som är oberoende av indatastorleken. De enda variablerna som används i koden är i, j, str och str2, som var och en tar upp en konstant mängd utrymme. Inget extra utrymme skapas i koden.

3. Rekursiv syn på P alindrome-program i Java

Tillvägagångssättet är mycket enkelt. Precis som tvåpekarmetoden kommer vi att kontrollera det första och det sista värdet på strängen men den här gången kommer det att ske genom rekursion.

• Vi kommer att ta två pekare i som pekar mot början av strängen och j pekar mot slutet av strängen.
• Fortsätt att öka i och minska j medan i
• Kontrollera om tecknen vid dessa pekare är desamma eller inte. Vi gör detta genom rekursion – (i+1, j-1
• Om alla tecknen är samma på det i:te och j:te indexet tills i>=j villkoret uppfylls, skriv ut true else false.

Nedan är implementeringen av ovanstående tillvägagångssätt:

latex teckenstorlekar

// 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) { return true; } // jämför tecknen på dessa pekare if (A.charAt(i) != A.charAt(j)) { return false; } // kontrollerar allt igen rekursivt returnerar isPalindrome(i + 1, j - 1, A); } public static boolean isPalindrome(String A) { return isPalindrome(0, A.length() - 1, A); } // huvudfunktion public static void main(String[] args) { // Inmatningssträng String A = 'geeks'; // Konvertera strängen till gemener A = A.toLowerCase(); boolean str = isPalindrome(A); System.out.println(str); } }>

false>

Komplexiteten av ovanstående metod:

Tidskomplexitet: Tidskomplexiteten för den givna koden är O(n), där n är längden på inmatningssträngen. Detta beror på att 'isPalindrome'-funktionen rekursivt anropar sig själv för tecknen på positionerna (i+1, j-1) tills pekarna i och j korsar varandra eller att tecknen vid pekarna inte är lika. Eftersom vi jämför varje tecken i strängen exakt en gång, är tidskomplexiteten O(n).

Utrymmes komplexitet: Kodens rymdkomplexitet är O(n), där n är längden på inmatningssträngen. Detta beror på att varje rekursivt anrop skapar en ny stackram som lagrar de aktuella värdena för funktionsparametrarna och lokala variabler. I värsta fall kan funktionsanropsstacken växa så stor som n/2 (när inmatningssträngen är en palindrom), så rymdkomplexiteten är O(n).

4. Använda StringBuilder Approach i Java

I detta tillvägagångssätt,

• Först tar vi stränginmatningen från användaren.
• Sedan skapar vi Stringbuilder-objektet str1″och lagrar värdet av String i det.
• Metoden reverse() i Stringbuider ger oss den omvända strängen. Ee lagra den omvända strängen i str1.
• Med hjälp av metoden equals() jämför vi strängens värden, med hjälp av if and else condition check är strängvärdet lika eller inte.

Nedan är implementeringen av ovanstående tillvägagångssätt:

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>

Komplexiteten i ovanstående kod:

full huggorm

Tidskomplexitet: Kodens tidskomplexitet är O(n), där n återigen är längden på inmatningssträngen str. Den primära faktorn som bidrar till denna tidskomplexitet är omkastningen av strängen med str1.reverse(). Att vända en sträng på detta sätt har en tidskomplexitet på O(n), där n är längden på strängen. Andra operationer i koden, som att läsa indata och jämföra strängarna, är konstanttidsoperationer och påverkar inte den totala tidskomplexiteten nämnvärt.

Utrymmes komplexitet: Rymdkomplexiteten för den givna Java-koden är O(n), där n är längden på inmatningssträngen str. Detta beror på att koden använder en StringBuilder för att lagra en omvänd kopia av inmatningssträngen, och utrymmet som krävs för StringBuilder är proportionellt mot längden på inmatningssträngen.

Referens

För att veta mer om Palindrome se Program för String Palindrome .