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

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: Annetun koodin aikamonimutkaisuus on O(n), missä n on syötetyn merkkijonon pituus. Tämä johtuu siitä, että while-silmukka iteroi puolet merkkijonosta tarkistaakseen, onko se palindromi. Koska tarkistamme vain puolet merkkijonosta, iteraatioiden määrä on verrannollinen n/2:een, joka on O(n).

Tilan monimutkaisuus: Koodin tilamonimutkaisuus on O(1), koska koodi käyttää vain vakiomäärän lisätilaa, joka on riippumaton syötteen koosta. Ainoat koodissa käytetyt muuttujat ovat i, j ja str, jotka kumpikin vievät vakiomäärän tilaa. Koodiin ei luoda lisätilaa.

Esimerkki 2:

ilmainen vs ilmainen

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

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: Annetun koodin aikamonimutkaisuus on O(n), missä n on syötetyn merkkijonon pituus. Tämä johtuu siitä, että 'isPalindrome'-menetelmän while-silmukka iteroi puolet merkkijonosta tarkistaakseen, onko kyseessä palindromi. Koska tarkistamme vain puolet merkkijonosta, iteraatioiden määrä on verrannollinen n/2:een, joka on O(n).

Tilan monimutkaisuus: Koodin tilamonimutkaisuus on O(1), koska koodi käyttää vain vakiomäärän lisätilaa, joka on riippumaton syötteen koosta. Ainoat koodissa käytetyt muuttujat ovat i, j, str ja str2, jotka kumpikin vievät vakiomäärän tilaa. Koodiin ei luoda lisätilaa.

iteroiva kartta java

3. Rekursiivinen lähestymistapa P:lle alindrome-ohjelma Javassa

Lähestymistapa on hyvin yksinkertainen. Kuten kahden osoittimen menetelmässä, tarkistamme merkkijonon ensimmäisen ja viimeisen arvon, mutta tällä kertaa se tapahtuu rekursion kautta.

• Otamme kaksi osoitinta i, jotka osoittavat merkkijonon alkuun ja j osoittavat merkkijonon loppuun.
• Jatka i:n lisäämistä ja j:n pienentämistä samalla kun i
• Tarkista, ovatko näiden osoittimien merkit samat vai eivät. Teemme tämän rekursion avulla – (i+1, j-1
• Jos kaikki merkit ovat samat i:nnessä ja j:nnessä indeksissä, kunnes i>=j-ehto täyttyy, tulosta tosi, muuten epätosi.

Alla on yllä olevan lähestymistavan toteutus:

// 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; } // näiden osoittimien merkkien vertailu if (A.charAt(i) != A.charAt(j)) { return false; } // kaiken tarkistaminen uudelleen rekursiivisesti return isPalindromi(i + 1, j - 1, A); } public staattinen boolean isPalindromi(String A) { return isPalindrom(0, A.length() - 1, A); } // pääfunktio public static void main(String[] args) { // Syöttömerkkijono Merkkijono A = 'geeks'; // Muunna merkkijono pieniksi kirjaimiksi A = A.toLowerCase(); boolen str = isPalindromi(A); System.out.println(str); } }>

false>

Yllä olevan menetelmän monimutkaisuus:

Aika monimutkaisuus: Annetun koodin aikamonimutkaisuus on O(n), missä n on syötetyn merkkijonon pituus. Tämä johtuu siitä, että 'isPalindromi'-funktio kutsuu itseään rekursiivisesti kohdissa (i+1, j-1) oleville merkeille, kunnes osoittimet i ja j kohtaavat toisensa tai osoittimissa olevat merkit eivät ole samanarvoisia. Koska vertaamme merkkijonon kutakin merkkiä täsmälleen kerran, aika monimutkaisuus on O(n).

Tilan monimutkaisuus: Koodin monimutkaisuus on O(n), missä n on syötetyn merkkijonon pituus. Tämä johtuu siitä, että jokainen rekursiivinen kutsu luo uuden pinokehyksen, joka tallentaa funktioparametrien ja paikallisten muuttujien nykyiset arvot. Pahimmassa tapauksessa funktiokutsupino voi kasvaa jopa n/2:ksi (kun syötemerkkijono on palindromi), joten tilan monimutkaisuus on O(n).

lista taulukkona

4. StringBuilder Approachin käyttäminen Javassa

Tässä lähestymistavassa

• Ensin otamme käyttäjältä merkkijonon syötteen.
• Sitten luomme Stringbuilder-objektin str1″ ja tallennamme siihen merkkijonon arvon.
• Stringbuiderin reverse()-metodi antaa meille käänteisen merkkijonon. Säilytä tämä käänteinen merkkijono str1:ssä.
• Equals()-metodin avulla vertaamme merkkijonon arvoja, if- ja else-ehtotarkistuksen avulla merkkijonon arvot ovat samanlaisia ​​vai eivät.

Alla on yllä olevan lähestymistavan toteutus:

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>

Yllä olevan koodin monimutkaisuus:

Aika monimutkaisuus: Koodin aikamonimutkaisuus on O(n), missä n on jälleen syötetyn merkkijonon str pituus. Ensisijainen tähän ajalliseen monimutkaisuuteen vaikuttava tekijä on merkkijonon kääntäminen str1.reverse(:llä). Merkkijonon kääntämisen tällä tavalla aikamonimutkaisuus on O(n), missä n on merkkijonon pituus. Muut koodin toiminnot, kuten syötteen lukeminen ja merkkijonojen vertailu, ovat vakioaikaisia ​​operaatioita eivätkä vaikuta merkittävästi yleiseen ajan monimutkaisuuteen.

Tilan monimutkaisuus: Annetun Java-koodin monimutkaisuus on O(n), missä n on syötemerkkijonon str pituus. Tämä johtuu siitä, että koodi käyttää StringBuilder-ohjelmaa syötemerkkijonon käänteisen kopion tallentamiseen, ja StringBuilderin tarvitsema tila on verrannollinen syötemerkkijonon pituuteen.

Viite

Lisätietoja Palindromesta on osoitteessa Ohjelma String Palindromelle .