In der Serie "Named Problems" stelle ich dir klassische, namentlich bekannte Algorithmus-Probleme vor, die seit Jahrzehnten in Ausbildung, Studium und Interviews verwendet werden. Anhand verständlicher Problemstellungen wie FizzBuzz, Türme von Hanoi oder dem Sieb des Eratosthenes lernst du hier, algorithmisch zu denken, Lösungsstrategien zu entwickeln und diese sauber in Java umzusetzen.

Ein Palindrom ist eine Zeichenfolge (oder Zahl), die vorwärts gelesen genauso aussieht wie rückwärts. Klassiker sind Wörter wie anna oder Zahlen wie 12321.

Dieses Problem ist so bekannt, weil es dich sehr sauber zu Grundthemen führt: Schleifen, Vergleiche und ein klarer Kontrollfluss mit Abbruchbedingungen.

In diesem Artikel lernst du, wie du Palindrome in Java erkennst: erst ganz straightforward, dann etwas idiomatischer und mit frühem Abbruch. Nebenbei übst du saubere Methoden, Parameter und Rückgabewerte.

 

Problemstellung

Schreibe eine Funktion, die prüft, ob ein gegebener String ein Palindrom ist.

  • Ein Palindrom liest sich von links nach rechts genauso wie von rechts nach links.
  • Wir betrachten hier die Eingabe genau so, wie sie ist: Groß-/Kleinschreibung und Leerzeichen zählen mit.
  • Die Funktion soll einen boolean Rückgabewert liefern.

Mini-Beispiele:

  • anna ist ein Palindrom.
  • otto ist ein Palindrom.
  • Hallo ist kein Palindrom (H != o).

 

Die Idee dahinter

Das Kernkonzept hier ist: Strings, Schleifen, Vergleich. Du vergleichst Zeichen an passenden Positionen: das erste mit dem letzten, das zweite mit dem vorletzten, und so weiter.

Wenn irgendwo ein Unterschied auftaucht, kannst du sofort sagen: kein Palindrom. Wenn alle Paare passen, ist es ein Palindrom.

  • Index links startet bei 0
  • Index rechts startet bei length - 1
  • Nach jedem Vergleich: links +1, rechts -1
  • Abbruch: sobald links >= rechts

 

Schritt für Schritt zur Lösung

  1. Lege zwei Zeiger an: left am Anfang und right am Ende des Strings.
  2. Vergleiche text.charAt(left) mit text.charAt(right).
  3. Wenn sie unterschiedlich sind, gib sofort false zurück.
  4. Wenn sie gleich sind, bewege die Zeiger: left++ und right--.
  5. Wenn die Zeiger sich treffen oder überkreuzen, gib true zurück.

 

Java-Implementierung (Variante A: straightforward)

public class PalindromeStraightforward {
  public static void main(String[] args) {
    System.out.println(isPalindromeByReversing("anna"));   // true
    System.out.println(isPalindromeByReversing("otto"));   // true
    System.out.println(isPalindromeByReversing("Hallo"));  // false
    System.out.println(isPalindromeByReversing(""));       // true
  }

  public static boolean isPalindromeByReversing(String text) {
    if (text == null) {
      return false;
    }

    String reversed = reverse(text);
    return text.equals(reversed);
  }

  private static String reverse(String text) {
    StringBuilder sb = new StringBuilder();

    for (int i = text.length() - 1; i >= 0; i--) {
      sb.append(text.charAt(i));
    }

    return sb.toString();
  }
}

Diese Variante ist leicht zu verstehen: Du baust den String rückwärts neu auf und vergleichst dann mit equals. Das funktioniert gut für Einsteiger, weil der Kontrollfluss simpel ist. Nachteil: Du erzeugst einen zusätzlichen String, also mehr Arbeit und Speicher als nötig.

 

Java-Implementierung (Variante B: Alternative oder Verbesserung)

public class PalindromeTwoPointers {
  public static void main(String[] args) {
    System.out.println(isPalindromeTwoPointers("anna"));    // true
    System.out.println(isPalindromeTwoPointers("otto"));    // true
    System.out.println(isPalindromeTwoPointers("Hallo"));   // false
    System.out.println(isPalindromeTwoPointers("abca"));    // false
    System.out.println(isPalindromeTwoPointers("a"));       // true
  }

  public static boolean isPalindromeTwoPointers(String text) {
    if (text == null) {
      return false;
    }

    int left = 0;
    int right = text.length() - 1;

    while (left < right) {
      char a = text.charAt(left);
      char b = text.charAt(right);

      if (a != b) {
        return false;
      }

      left++;
      right--;
    }

    return true;
  }
}

Hier vergleichst du direkt von außen nach innen. Das ist meist die bessere Lösung: kein zusätzlicher String, und du kannst bei der ersten Abweichung sofort abbrechen. Die Laufzeit wächst dabei grob linear mit der Länge des Strings, weil jedes Zeichen höchstens einmal in einen Vergleich geht.

 

Beispiel: Eingabe und Ausgabe

  • Eingabe anna → Ausgabe true
  • Eingabe abca → Ausgabe false
  • Eingabe Hallo → Ausgabe false

 

Typische Fehler

  • Null nicht behandelt:
    Bei null direkt charAt zu nutzen fuehrt zu NullPointerException.

  • Falscher Startindex rechts:
    right = text.length() statt text.length() - 1 führt zu StringIndexOutOfBoundsException.

  • Falsche Schleifenbedingung:
    left <= right ist nicht kaputt, aber oft unnötig und verleitet zu Denkfehlern bei Updates.

  • Zeiger nicht bewegt:
    left++ oder right-- vergessen endet in einer Endlosschleife.

  • Vergleich mit == bei Strings:
    text == reversed vergleicht Referenzen statt Inhalte; nutze equals.

  • Gross-/Kleinschreibung übersehen:
    Anna ist in dieser Aufgabenvariante kein Palindrom, weil A != a.

 

Fazit

Du hast gelernt, was ein Palindrom ist und wie du es in Java prüfst: einmal über das Umdrehen des Strings und einmal effizienter mit zwei Zeigern. Dabei hast du sauberen Kontrollfluss, klare Abbruchbedingungen und Zeichenvergleiche geübt.

Wenn du die Zwei-Zeiger-Idee verstanden hast, erkennst du sie später in vielen bekannten Problemen wieder.