Chaturmind
LearnDSASystem DesignBlogPremium
Sign inGet started
Chaturmind

Structured learning paths for engineers who want to go deep. Written by practitioners.

Learn

  • Java
  • DSA
  • System Design
  • Spring Boot
  • AI / ML

Company

  • Blog
  • Premium
  • Contact

Legal

  • Privacy Policy
  • Terms of Service

© 2026 Chaturmind. All rights reserved.

Built for engineers who want to go deep.


← Arrays & Strings Mastery

Core Patterns

  • Two Pointers Pattern
  • Sliding Window Pattern
  • Prefix Sums

String Problems

  • String Hashing & Anagrams
  • String Two-Pointer Problems
Chaturmind
← Arrays & Strings Mastery

Core Patterns

  • Two Pointers Pattern
  • Sliding Window Pattern
  • Prefix Sums

String Problems

  • String Hashing & Anagrams
  • String Two-Pointer Problems
HomeLearnDSAArrays & Strings MasteryString Patterns
✓ FreeIntermediate· 12 min read

String Two Pointer Techniques

Apply two-pointer inward scanning to palindrome, reverse, and character filtering problems.

Published March 8, 2025


String Two Pointer Techniques

Two pointers on strings — typically one starting from each end and moving inward — elegantly solve palindrome checking, string reversal, and character filtering problems in O(n) time with O(1) space.

Valid Palindrome (ignore non-alphanumeric)

public boolean isPalindrome(String s) {
    int left = 0, right = s.length() - 1;
    while (left < right) {
        while (left < right && !Character.isLetterOrDigit(s.charAt(left)))  left++;
        while (left < right && !Character.isLetterOrDigit(s.charAt(right))) right--;
        if (Character.toLowerCase(s.charAt(left)) !=
            Character.toLowerCase(s.charAt(right))) return false;
        left++;
        right--;
    }
    return true;
}

Almost Palindrome (at most one deletion)

public boolean validPalindrome(String s) {
    int left = 0, right = s.length() - 1;
    while (left < right) {
        if (s.charAt(left) != s.charAt(right)) {
            // Try skipping left or right character
            return isPalin(s, left + 1, right) || isPalin(s, left, right - 1);
        }
        left++;
        right--;
    }
    return true;
}

private boolean isPalin(String s, int l, int r) {
    while (l < r) {
        if (s.charAt(l++) != s.charAt(r--)) return false;
    }
    return true;
}

Reverse a String In-Place

public void reverseString(char[] s) {
    int left = 0, right = s.length - 1;
    while (left < right) {
        char tmp = s[left];
        s[left++] = s[right];
        s[right--] = tmp;
    }
}

Reverse Words in a String

public String reverseWords(String s) {
    // Trim, split on whitespace, reverse array, join
    String[] words = s.trim().split("\\s+");
    int left = 0, right = words.length - 1;
    while (left < right) {
        String tmp = words[left];
        words[left++] = words[right];
        words[right--] = tmp;
    }
    return String.join(" ", words);
}

Two-Pointer on Sorted Characters

// Merge two sorted strings (like merge sort step)
public String mergeSorted(String a, String b) {
    StringBuilder sb = new StringBuilder();
    int i = 0, j = 0;
    while (i < a.length() && j < b.length()) {
        if (a.charAt(i) <= b.charAt(j)) sb.append(a.charAt(i++));
        else sb.append(b.charAt(j++));
    }
    while (i < a.length()) sb.append(a.charAt(i++));
    while (j < b.length()) sb.append(b.charAt(j++));
    return sb.toString();
}

Minimum Window Substring (Two Pointers + Frequency)

// Find smallest window in s containing all chars of t
public String minWindow(String s, String t) {
    int[] need = new int[128];
    for (char c : t.toCharArray()) need[c]++;
    int required = t.length();
    int left = 0, min = Integer.MAX_VALUE, start = 0;

    for (int right = 0; right < s.length(); right++) {
        if (need[s.charAt(right)]-- > 0) required--;

        while (required == 0) { // window is valid
            if (right - left + 1 < min) {
                min = right - left + 1;
                start = left;
            }
            if (need[s.charAt(left++)]++ == 0) required++;
        }
    }
    return min == Integer.MAX_VALUE ? "" : s.substring(start, start + min);
}

Interview Tips

  1. Two-pointer palindrome check is O(n) time, O(1) space — much better than reversing the string.
  2. The "skip one character" trick in validPalindrome is a classic follow-up to basic palindrome.
  3. For the minimum window problem, the pattern of shrinking from the left when the window is valid is a fundamental sliding window technique.

Previous

String Hashing & Anagrams

AI Tutor

Lesson: String Two Pointer Techniques

Quick actions

AI responses can be inaccurate. Verify critical information.