Příklad 1:

prázdno 0

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

Složitost výše uvedené metody:

Časová náročnost: Časová složitost daného kódu je O(n), kde n je délka vstupního řetězce. Je to proto, že smyčka while iteruje polovinu řetězce, aby zkontrolovala, zda se jedná o palindrom. Protože kontrolujeme pouze polovinu řetězce, počet iterací je úměrný n/2, což je O(n).

Prostorová složitost: Prostorová složitost kódu je O(1), protože kód používá pouze konstantní množství dalšího prostoru, který je nezávislý na velikosti vstupu. Jediné proměnné použité v kódu jsou i, j a str, z nichž každá zabírá konstantní množství místa. V kódu není vytvořen žádný další prostor.

Příklad 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>

Složitost výše uvedené metody:

Časová náročnost: Časová složitost daného kódu je O(n), kde n je délka vstupního řetězce. Je to proto, že smyčka while v metodě `isPalindrome` iteruje polovinu řetězce, aby zkontrolovala, zda se jedná o palindrom. Protože kontrolujeme pouze polovinu řetězce, počet iterací je úměrný n/2, což je O(n).

Prostorová složitost: Prostorová složitost kódu je O(1), protože kód používá pouze konstantní množství dalšího prostoru, který je nezávislý na velikosti vstupu. Jediné proměnné použité v kódu jsou i, j, str a str2, z nichž každá zabírá konstantní množství místa. V kódu není vytvořen žádný další prostor.

3. Rekurzivní přístup pro P alindrome program v Javě

Přístup je velmi jednoduchý. Stejně jako u dvoubodového přístupu zkontrolujeme první a poslední hodnotu řetězce, ale tentokrát to bude pomocí rekurze.

• Vezmeme dva ukazatele i ukazující na začátek řetězce a j ukazující na konec řetězce.
• Pokračujte ve zvyšování i a snižování j, zatímco i
• Zkontrolujte, zda jsou znaky na těchto ukazatelích stejné nebo ne. Děláme to pomocí rekurze – (i+1, j-1
• Pokud jsou všechny znaky na i-tém a j-tém indexu stejné, dokud nesplní podmínka i>=j, vytiskne true, jinak false.

Níže je uvedena implementace výše uvedeného přístupu:

rozhraní vs abstraktní třída

// 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; } // porovnání znaků na těchto ukazatelích if (A.charAt(i) != A.charAt(j)) { return false; } // vše znovu rekurzivně zkontrolujeme return isPalindrome(i + 1, j - 1, A); } public static boolean isPalindrome(String A) { return isPalindrome(0, A.length() - 1, A); } // hlavní funkce public static void main(String[] args) { // Vstupní řetězec String A = 'geeks'; // Převede řetězec na malá písmena A = A.toLowerCase(); boolean str = isPalindrome(A); System.out.println(str); } }>

false>

Složitost výše uvedené metody:

Časová náročnost: Časová složitost daného kódu je O(n), kde n je délka vstupního řetězce. Je to proto, že funkce `isPalindrome` rekurzivně volá sama sebe pro znaky na pozicích (i+1, j-1), dokud se ukazatele i a j vzájemně nekříží nebo si znaky na ukazatelích nejsou stejné. Protože každý znak v řetězci porovnáváme právě jednou, je časová složitost O(n).

Prostorová složitost: Prostorová složitost kódu je O(n), kde n je délka vstupního řetězce. Je to proto, že každé rekurzivní volání vytváří nový zásobníkový rámec, který ukládá aktuální hodnoty parametrů funkce a lokálních proměnných. V nejhorším případě může zásobník volání funkcí narůst až na n/2 (když je vstupním řetězcem palindrom), takže prostorová složitost je O(n).

4. Použití StringBuilder Approach v Javě

V tomto přístupu

• Nejprve převezmeme vstup String od uživatele.
• Poté vytvoříme objekt Stringbuilder str1″ a uložíme do něj hodnotu String.
• Metoda reverse() v Stringbuider nám poskytuje obrácený řetězec. Ee uložte ten obrácený řetězec v str1.
• Pomocí metody equals() porovnáváme hodnoty řetězce, pomocí if a else condition check jsou hodnoty řetězce podobné nebo ne.

Níže je uvedena implementace výše uvedeného přístupu:

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>

Složitost výše uvedeného kódu:

číslo 1 milion

Časová náročnost: Časová složitost kódu je O(n), kde n je opět délka vstupního řetězce str. Primárním faktorem přispívajícím k této časové složitosti je obrácení řetězce pomocí str1.reverse(). Obrácení řetězce tímto způsobem má časovou složitost O(n), kde n je délka řetězce. Ostatní operace v kódu, jako je čtení vstupu a porovnávání řetězců, jsou operace s konstantním časem a nemají významný vliv na celkovou časovou složitost.

Prostorová složitost: Prostorová složitost daného Java kódu je O(n), kde n je délka vstupního řetězce str. Důvodem je, že kód používá StringBuilder k uložení obrácené kopie vstupního řetězce a prostor požadovaný pro StringBuilder je úměrný délce vstupního řetězce.

Odkaz

Chcete-li se dozvědět více o Palindromu, viz Program pro String Palindrom .