DSA Fundamentals: Two Pointers & Sliding Window - From Theory to LeetCode Practice

Jay Kye

November 01, 2025

21 min read

Master two pointers and sliding window techniques through theory and practical LeetCode problem solving. Covering variable and fixed-length windows, palindrome validation, substring problems, and optimization strategies.

DSATwo PointersSliding WindowLeetCodeAlgorithmsProblem SolvingOptimization

Two Pointers and Sliding Window are powerful algorithmic techniques that optimize array and string problems from O(n²) brute force to O(n) linear time. These patterns appear frequently in coding interviews and real-world applications, especially when dealing with subsequences, subarrays, or substring problems.

This comprehensive guide combines theoretical understanding with practical problem-solving, featuring solutions to essential LeetCode problems that demonstrate core concepts.

Understanding Two Pointers Technique

Two Pointers Fundamentals

Two Pointers is an efficient technique that uses two indices to traverse data structures, typically arrays or strings. Instead of nested loops, two pointers move through the data structure based on specific conditions.

Common Two Pointers Patterns

1. Opposite Directional (Convergent):

Pointers start from both ends (index 0 and last index)
Move inward based on conditions
Loop terminates when pointers meet
Use cases: Palindrome validation, sorted array problems, container problems

2. Same Directional (Chasing):

Both pointers start from the same end
Move at different speeds based on conditions
Use cases: Fast-slow pointer, removing duplicates

3. Applications:

Can be used standalone
Combined with binary search
Integrated within sliding window
Part of multi-pointer algorithms (e.g., 3Sum)

Time Complexity Analysis

Pattern	Time Complexity	Space Complexity	Notes
Basic Two Pointers	O(n)	O(1)	Single pass through array
With Binary Search	O(log n)	O(1)	Halves search space each iteration
Three Pointers (3Sum)	O(n²)	O(1)	One fixed, two moving pointers
With Sorting	O(n log n)	O(1)	Dominated by sort operation

Understanding Sliding Window Technique

Sliding Window Fundamentals

Sliding Window is an optimization technique for solving problems involving contiguous subarrays or substrings. Instead of recalculating for each window position, we maintain a window and slide it through the data structure.

Two Types of Sliding Windows

1. Variable Length Window

Pattern:

Expand window by moving right pointer
Process elements as they enter window
When condition violated, shrink by moving left pointer
Update result (max/min window size, count, etc.)
Continue until right pointer reaches end

Use cases: Longest substring problems, dynamic size constraints

# Variable Length Window Template
def variable_window(arr):
    left = 0
    result = 0
    window_state = {}  # Track window state
    
    for right in range(len(arr)):
        # Expand window: add arr[right]
        # Update window state
        
        while condition_violated:
            # Shrink window: remove arr[left]
            # Update window state
            left += 1
        
        # Update result with current window
        result = max(result, right - left + 1)
    
    return result

2. Fixed Length Window

Pattern:

Calculate result for first window of size k
Slide window: remove leftmost element, add new rightmost element
Update result for each window position
Continue until end of array

Use cases: Maximum sum of k elements, average calculations

# Fixed Length Window Template
def fixed_window(arr, k):
    # Calculate first window
    window_sum = sum(arr[:k])
    result = window_sum
    
    # Slide window through array
    for i in range(k, len(arr)):
        window_sum = window_sum - arr[i - k] + arr[i]
        result = max(result, window_sum)
    
    return result

Window Operations Time Complexity

Operation	Time Complexity	Notes
Initialize window	O(k)	First k elements
Slide window	O(1)	Add one, remove one
Variable window (full pass)	O(n)	Each element visited at most twice
Fixed window (full pass)	O(n)	Single pass after initialization

Essential LeetCode Problems & Solutions

Let's explore fundamental two pointers and sliding window problems that demonstrate core algorithmic patterns.

Two Pointers Problems

1. Valid Palindrome (LeetCode 125)

Problem: Check if a string is a palindrome, considering only alphanumeric characters and ignoring case.

Approach: Use two pointers from both ends, skip non-alphanumeric characters, compare values.

class Solution:
    def isPalindrome(self, s: str) -> bool:
        # Convert to lowercase for case-insensitive comparison
        s = s.lower()
        left = 0
        right = len(s) - 1
        
        while left < right:
            # Skip non-alphanumeric characters from left
            while left < right and not s[left].isalnum():
                left += 1
            
            # Skip non-alphanumeric characters from right
            while left < right and not s[right].isalnum():
                right -= 1
            
            # Compare characters
            if s[left] != s[right]:
                return False
            
            left += 1
            right -= 1
        
        return True

Time Complexity: O(n) - Single pass through string
Space Complexity: O(1) - Only using two pointers

Key Concepts:

Two-pointer convergence: Start from both ends, meet in middle
Character filtering: Skip non-alphanumeric on the fly
Early termination: Return False immediately on mismatch
Edge case handling: Empty strings and single characters are palindromes

2. Two Sum II - Input Array Is Sorted (LeetCode 167)

Problem: Find two numbers in a sorted array that add up to a target value. Return 1-indexed positions.

Approach: Use two pointers from both ends, adjust based on sum comparison with target.

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        left = 0
        right = len(numbers) - 1
        
        while left < right:
            current_sum = numbers[left] + numbers[right]
            
            # Found the target
            if current_sum == target:
                return [left + 1, right + 1]  # 1-indexed
            
            # Sum too small, need larger number
            if current_sum < target:
                left += 1
            # Sum too large, need smaller number
            else:
                right -= 1
        
        return []  # No solution found

Time Complexity: O(n) - Single pass through array
Space Complexity: O(1) - Only using two pointers

Key Concepts:

Sorted array advantage: Enables two-pointer approach
Binary decision: Move left (increase sum) or right (decrease sum)
Guaranteed solution: Problem guarantees exactly one solution
Comparison with unsorted: O(n) here vs O(n²) brute force or O(n) with hash map

3. Container With Most Water (LeetCode 11)

Problem: Given array of heights, find two lines that form container holding the most water.

Approach: Two pointers from both ends, move pointer with shorter height inward to potentially find larger area.

class Solution:
    def maxArea(self, height: List[int]) -> int:
        left = 0
        right = len(height) - 1
        max_area = 0
        
        while left < right:
            # Calculate current area
            width = right - left
            current_height = min(height[left], height[right])
            current_area = width * current_height
            
            # Update maximum area
            max_area = max(max_area, current_area)
            
            # Move pointer with shorter height
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1
        
        return max_area

Time Complexity: O(n) - Single pass through array
Space Complexity: O(1) - Only tracking area variables

Key Concepts:

Greedy approach: Always move shorter height pointer
Area calculation: width * min(height[left], height[right])
Why move shorter height?: Moving taller height can only decrease width without height benefit
Optimal substructure: Each step makes locally optimal choice

4. 3Sum (LeetCode 15)

Problem: Find all unique triplets in array that sum to zero.

Approach: Fix one element, use two pointers for remaining two elements. Sort first to handle duplicates and enable two-pointer technique.

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        # Sort for two-pointer approach and duplicate handling
        nums.sort()
        n = len(nums)
        result = []
        
        for i in range(n):
            # Early termination: if current number positive, no way to sum to 0
            if nums[i] > 0:
                break
            
            # Skip duplicate elements for first number
            if i > 0 and nums[i] == nums[i-1]:
                continue
            
            # Two pointers for remaining elements
            left = i + 1
            right = n - 1
            
            while left < right:
                current_sum = nums[i] + nums[left] + nums[right]
                
                if current_sum == 0:
                    result.append([nums[i], nums[left], nums[right]])
                    
                    # Skip duplicates for second number
                    while left < right and nums[left] == nums[left + 1]:
                        left += 1
                    # Skip duplicates for third number
                    while left < right and nums[right] == nums[right - 1]:
                        right -= 1
                    
                    left += 1
                    right -= 1
                
                elif current_sum < 0:
                    left += 1  # Need larger sum
                else:
                    right -= 1  # Need smaller sum
        
        return result

Time Complexity: O(n²) - Outer loop O(n) × inner two pointers O(n)
Space Complexity: O(1) - Ignoring output array, only using pointers

Key Concepts:

Fixed + two pointers: Reduces 3Sum to 2Sum problem
Duplicate handling: Skip same values to avoid duplicate triplets
Sorting requirement: Enables two-pointer approach and duplicate skipping
Early termination: If smallest number is positive, impossible to sum to 0

5. Trapping Rain Water (LeetCode 42)

Problem: Calculate how much rainwater can be trapped between elevation heights.

Approach: Two pointers with max height tracking from both ends. Water trapped at each position depends on minimum of max heights from both sides.

class Solution:
    def trap(self, height: List[int]) -> int:
        if not height:
            return 0
        
        left = 0
        right = len(height) - 1
        left_max = 0
        right_max = 0
        total_water = 0
        
        while left < right:
            # Process from side with lower maximum
            if height[left] <= height[right]:
                # Update left max height
                left_max = max(left_max, height[left])
                # Water trapped = max height - current height
                total_water += left_max - height[left]
                left += 1
            else:
                # Update right max height
                right_max = max(right_max, height[right])
                # Water trapped = max height - current height
                total_water += right_max - height[right]
                right -= 1
        
        return total_water

Time Complexity: O(n) - Single pass through array
Space Complexity: O(1) - Only tracking max values and pointers

Key Concepts:

Two-pointer optimization: Avoid two-pass solution
Max height tracking: Water level determined by minimum of left_max and right_max
Water calculation: max_height - current_height at each position
Greedy processing: Always process side with lower maximum height
Why it works: Water trapped at position depends only on minimum barrier height

Sliding Window Problems

6. Best Time to Buy and Sell Stock (LeetCode 121)

Problem: Find maximum profit from single buy and sell transaction. Can only sell after buying.

Approach: Track minimum price seen so far, calculate profit at each position, update maximum profit.

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        min_price = prices[0]
        max_profit = 0
        
        for price in prices:
            # Update minimum price seen so far
            min_price = min(price, min_price)
            
            # Calculate profit if we sell today
            current_profit = price - min_price
            
            # Update maximum profit
            max_profit = max(current_profit, max_profit)
        
        return max_profit

Time Complexity: O(n) - Single pass through array
Space Complexity: O(1) - Only tracking min and max values

Key Concepts:

One-pass solution: No need to check all pairs
Running minimum: Track lowest price seen so far (best buy point)
Profit calculation: Current price - minimum price
Greedy approach: Always buy at lowest seen price, sell at current
Edge case: If prices only decrease, max_profit remains 0

7. Longest Substring Without Repeating Characters (LeetCode 3)

Problem: Find length of longest substring without repeating characters.

Approach: Variable-length sliding window with set to track characters. Expand window until duplicate found, then shrink until duplicate removed.

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        char_set = set()
        left = 0
        longest = 0
        
        for right in range(len(s)):
            # Shrink window while duplicate exists
            while s[right] in char_set:
                char_set.remove(s[left])
                left += 1
            
            # Add current character to window
            char_set.add(s[right])
            
            # Calculate window size and update longest
            window_size = right - left + 1
            longest = max(longest, window_size)
        
        return longest

Time Complexity: O(n) - Each character visited at most twice (once by right, once by left)
Space Complexity: O(min(n, k)) - k is character set size (26 for lowercase letters)

Key Concepts:

Variable window: Expands and shrinks based on duplicate condition
Set for tracking: O(1) lookup for duplicates
Window maintenance: Remove from left until no duplicates
Size calculation: right - left + 1
Each element visited twice maximum: Right pointer adds, left pointer removes

8. Longest Repeating Character Replacement (LeetCode 424)

Problem: Find length of longest substring with same letter after replacing at most k characters.

Approach: Variable-length window tracking character frequencies. Shrink when window_size - max_frequency > k.

class Solution:
    def characterReplacement(self, s: str, k: int) -> int:
        char_count = {}
        left = 0
        longest = 0
        
        for right in range(len(s)):
            # Add current character to window
            char_count[s[right]] = char_count.get(s[right], 0) + 1
            
            # Shrink window if replacement count exceeds k
            # window_size - most_frequent_char = replacements_needed
            while (right - left + 1) - max(char_count.values()) > k:
                char_count[s[left]] -= 1
                left += 1
            
            # Update longest valid window
            window_size = right - left + 1
            longest = max(longest, window_size)
        
        return longest

Time Complexity: O(n × 26) = O(n) - For each position, find max in char_count (at most 26 characters)
Space Complexity: O(26) = O(1) - Fixed size hash map for alphabet

Key Concepts:

Replacement logic: window_size - max_frequency = replacements_needed
Window validity: Valid when replacements needed ≤ k
Frequency tracking: Count each character in current window
Max frequency optimization: Most frequent character should stay, replace others
No need to shrink perfectly: Window never shrinks below previously valid size

9. Permutation in String (LeetCode 567)

Problem: Check if one string's permutation is substring of another string.

Approach: Fixed-length sliding window matching character frequencies. Compare frequency maps.

class Solution:
    def checkInclusion(self, s1: str, s2: str) -> bool:
        len1 = len(s1)
        len2 = len(s2)
        
        # Edge case: s1 longer than s2
        if len1 > len2:
            return False
        
        # Build frequency maps
        s1_map = {}
        s2_map = {}
        
        # Initialize first window
        for i in range(len1):
            s1_map[s1[i]] = s1_map.get(s1[i], 0) + 1
            s2_map[s2[i]] = s2_map.get(s2[i], 0) + 1
        
        # Check first window
        if s1_map == s2_map:
            return True
        
        # Slide window through rest of s2
        for i in range(len1, len2):
            # Add new character to window
            s2_map[s2[i]] = s2_map.get(s2[i], 0) + 1
            
            # Remove old character from window
            old_char = s2[i - len1]
            s2_map[old_char] -= 1
            if s2_map[old_char] == 0:
                del s2_map[old_char]
            
            # Check if current window matches s1
            if s1_map == s2_map:
                return True
        
        return False

Time Complexity: O(n) - Slide window through s2 once, map comparison is O(26) = O(1)
Space Complexity: O(1) - Hash maps store at most 26 characters

Key Concepts:

Fixed window size: Length of s1
Permutation = same frequency: Order doesn't matter
Sliding optimization: Update frequency map instead of recalculating
Map comparison: Python dict equality checks keys and values
Cleanup: Remove characters with 0 count for accurate comparison

Core Algorithm Patterns from Today's Problems

1. Two Pointers - Opposite Directional Pattern

When to use:

Array is sorted or sorting is beneficial
Looking for pairs/triplets that meet certain conditions
Optimizing from both ends simultaneously

Examples: Two Sum II, Valid Palindrome, Container With Most Water, 3Sum

Key characteristics:

Start from both ends (left = 0, right = n-1)
Move pointers based on comparison
O(n) time complexity for sorted arrays
Often combined with sorting for O(n log n) total

Template:

def two_pointers_opposite(arr):
    left = 0
    right = len(arr) - 1
    
    while left < right:
        if condition_met(arr[left], arr[right]):
            return result
        elif need_larger_value:
            left += 1
        else:
            right -= 1
    
    return default_result

2. Variable-Length Sliding Window Pattern

When to use:

Finding longest/shortest subarray/substring with certain property
Condition can be checked incrementally
Need to maintain a contiguous sequence

Examples: Longest Substring Without Repeating Characters, Longest Repeating Character Replacement

Key characteristics:

Expand window by incrementing right pointer
Shrink window by incrementing left pointer
Maintain window state (set, map, count)
Each element visited at most twice → O(n)

Template:

def variable_sliding_window(arr):
    left = 0
    window_state = {}
    result = 0
    
    for right in range(len(arr)):
        # Add arr[right] to window
        update_window_state(arr[right])
        
        # Shrink while invalid
        while not valid_window():
            remove_from_window(arr[left])
            left += 1
        
        # Update result
        result = max(result, right - left + 1)
    
    return result

3. Fixed-Length Sliding Window Pattern

When to use:

Window size is predetermined
Need to check all subarrays/substrings of specific length
Frequency/sum calculations over fixed ranges

Examples: Permutation in String, Maximum Average Subarray

Key characteristics:

Build initial window of size k
Slide: remove left element, add right element
O(n) time complexity after O(k) initialization
Simple sliding mechanism

Template:

def fixed_sliding_window(arr, k):
    # Build first window
    window_state = initialize_window(arr[:k])
    result = calculate_result(window_state)
    
    # Slide window
    for i in range(k, len(arr)):
        remove_element(arr[i - k])
        add_element(arr[i])
        result = update_result(window_state, result)
    
    return result

4. Multi-Pointer Pattern (3Sum)

When to use:

Problems requiring k elements with certain sum
Can be reduced to (k-1)-pointer problem
Sorting enables efficient searching

Example: 3Sum, 4Sum

Key characteristics:

Fix (k-2) elements with outer loops
Use two-pointer technique for remaining 2 elements
Time complexity: O(n^(k-1))
Careful duplicate handling required

Performance Optimization Tips

1. Two Pointers vs Hash Map Trade-offs

# Unsorted array: Hash map approach
def two_sum_unsorted(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        if target - num in seen:
            return [seen[target - num], i]
        seen[num] = i
# Time: O(n), Space: O(n)

# Sorted array: Two pointers approach  
def two_sum_sorted(nums, target):
    left, right = 0, len(nums) - 1
    while left < right:
        curr_sum = nums[left] + nums[right]
        if curr_sum == target:
            return [left, right]
        elif curr_sum < target:
            left += 1
        else:
            right -= 1
# Time: O(n), Space: O(1)

Key insight: Two pointers saves space when array is sorted or sorting cost is acceptable.

2. Set vs Hash Map for Sliding Window

# When only membership matters: Use Set
def longest_unique_substring(s):
    char_set = set()  # O(1) operations
    left = 0
    longest = 0
    
    for right in range(len(s)):
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        longest = max(longest, right - left + 1)
    return longest

# When frequency matters: Use Hash Map
def character_replacement(s, k):
    char_count = {}  # Need frequency for validation
    left = 0
    longest = 0
    
    for right in range(len(s)):
        char_count[s[right]] = char_count.get(s[right], 0) + 1
        while (right - left + 1) - max(char_count.values()) > k:
            char_count[s[left]] -= 1
            left += 1
        longest = max(longest, right - left + 1)
    return longest

Key insight: Use simplest data structure that satisfies requirements.

3. Early Termination in Two Pointers

def three_sum_optimized(nums):
    nums.sort()
    result = []
    
    for i in range(len(nums)):
        # Early termination: impossible to reach 0
        if nums[i] > 0:
            break  # All remaining numbers are positive
        
        # Skip duplicates
        if i > 0 and nums[i] == nums[i-1]:
            continue
        
        # Two pointers for remaining elements
        left, right = i + 1, len(nums) - 1
        while left < right:
            # ... rest of logic

Key insight: Check for impossible conditions before processing.

4. Avoiding Redundant Calculations

# Inefficient: Recalculate max every iteration
for right in range(len(s)):
    char_count[s[right]] += 1
    while (right - left + 1) - max(char_count.values()) > k:  # O(26) every iteration
        char_count[s[left]] -= 1
        left += 1

# Optimized: Track max frequency
max_freq = 0
for right in range(len(s)):
    char_count[s[right]] += 1
    max_freq = max(max_freq, char_count[s[right]])  # O(1) update
    while (right - left + 1) - max_freq > k:
        char_count[s[left]] -= 1
        left += 1

Key insight: For character replacement problem, max_freq only needs to increase (never decrease matters for longest result).

Common Pitfalls and Solutions

1. Off-by-One Errors in Window Size

# Wrong: Window size calculation
window_size = right - left  # Missing the +1

# Correct: Window size includes both endpoints
window_size = right - left + 1

# Example: left=2, right=5
# Elements at indices: [2, 3, 4, 5] = 4 elements
# Calculation: 5 - 2 + 1 = 4 ✓

2. Forgetting to Update Window State

# Wrong: Forget to add new element
for right in range(len(s)):
    # Process window
    while s[right] in char_set:
        char_set.remove(s[left])
        left += 1
    # ❌ Missing: char_set.add(s[right])
    longest = max(longest, right - left + 1)

# Correct: Always update window state
for right in range(len(s)):
    while s[right] in char_set:
        char_set.remove(s[left])
        left += 1
    char_set.add(s[right])  # ✓ Add current element
    longest = max(longest, right - left + 1)

3. Incorrect Duplicate Skipping in 3Sum

# Wrong: Skip current element
if nums[i] == nums[i-1]:  # Will skip first occurrence too!
    continue

# Correct: Skip after processing first occurrence
if i > 0 and nums[i] == nums[i-1]:  # Protect against i=0
    continue

4. Boundary Conditions in Two Pointers

# Dangerous: No boundary check in nested while loops
while s[right] in char_set:
    char_set.remove(s[left])
    left += 1  # Could exceed right

# Safe: Always check boundaries
while left < right and s[right] in char_set:
    char_set.remove(s[left])
    left += 1

5. Hash Map Cleanup Oversight

# Wrong: Leave zero-count entries
char_count[old_char] -= 1  # Could become 0, affecting map comparison

# Correct: Remove zero-count entries
char_count[old_char] -= 1
if char_count[old_char] == 0:
    del char_count[old_char]  # Clean up for accurate comparison

Time Complexity Comparison

Problem Complexity Summary

Problem	Brute Force	Optimized	Space	Technique
Valid Palindrome	O(n)	O(n)	O(1)	Two Pointers
Two Sum II	O(n²)	O(n)	O(1)	Two Pointers
Container With Most Water	O(n²)	O(n)	O(1)	Two Pointers
3Sum	O(n³)	O(n²)	O(1)	Sort + Two Pointers
Trapping Rain Water	O(n²)	O(n)	O(1)	Two Pointers
Best Time to Buy/Sell	O(n²)	O(n)	O(1)	Sliding Window
Longest Substring Unique	O(n³)	O(n)	O(k)	Variable Window + Set
Character Replacement	O(n² × k)	O(n × 26)	O(26)	Variable Window + Map
Permutation in String	O(n × m!)	O(n)	O(26)	Fixed Window + Map

Why These Techniques Are Efficient

Two Pointers eliminates nested loops:

Brute force: Check all pairs → O(n²)
Two pointers: Single pass from both ends → O(n)
Savings: O(n²) → O(n)

Sliding Window eliminates redundant calculations:

Brute force: Recalculate each subarray from scratch → O(n² × k)
Sliding window: Update incrementally → O(n)
Savings: O(n²) → O(n) or O(n³) → O(n)

Conclusion

Two Pointers and Sliding Window are essential optimization techniques that transform inefficient brute-force solutions into elegant, linear-time algorithms. Key takeaways:

Core Concepts Mastered:

Two Pointers:

Opposite directional: Converging from both ends (palindrome, two sum, container)
Same directional: Fast-slow pointer, removing duplicates
Multi-pointer: Extending to 3Sum, 4Sum problems
Sorted array advantage: Enables O(n) solutions

Sliding Window:

Variable length: Dynamic window based on conditions (longest substring)
Fixed length: Predetermined window size (permutation matching)
Window state: Set for membership, hash map for frequency
Incremental updates: Add/remove elements efficiently

Essential Patterns Mastered Today:

Pattern 1: Two-pointer convergence (Valid Palindrome, Two Sum II, Container With Most Water)
Pattern 2: Multi-pointer with sorting (3Sum, Trapping Rain Water)
Pattern 3: Variable-length sliding window (Longest Substring, Character Replacement)
Pattern 4: Fixed-length sliding window (Permutation in String)

Problem-Solving Strategies:

Identify contiguous sequences: Consider sliding window
Sorted array or pairs: Consider two pointers
Substring/subarray problems: Usually sliding window
Sum/product targets: Two pointers on sorted array
Longest/shortest with condition: Variable sliding window
Fixed-size calculations: Fixed sliding window

Optimization Principles:

Eliminate nested loops with two pointers
Update incrementally instead of recalculating
Use appropriate data structure (set vs map)
Sort when beneficial (enables two-pointer approach)
Skip duplicates efficiently (sorted arrays)
Early termination when possible

Next Steps:

Building on these patterns, future topics will cover:

Binary Search (can incorporate two pointers)
Stack and Queue Applications (monotonic structures)
Backtracking (with pruning optimizations)
Dynamic Programming (optimizing with sliding window)

The problems covered here represent fundamental optimization patterns that appear across technical interviews and competitive programming. Master these techniques, and you'll recognize opportunities to optimize O(n²) or O(n³) solutions to O(n) in many problems.

Practice Problems for Mastery:

Two Pointers:

15. 3Sum
1. 3Sum Closest
1. 4Sum
1. Remove Duplicates from Sorted Array
1. Move Zeroes
1. Reverse String
1. Squares of a Sorted Array

Sliding Window:

209. Minimum Size Subarray Sum
1. Find All Anagrams in a String
1. Max Consecutive Ones
1. Maximum Average Subarray I
1. Subarray Product Less Than K
1. Fruit Into Baskets
1. Max Consecutive Ones III

References:

NeetCode - Algorithms
LeetCode Patterns
Greg Hogg DSA Algorithm YouTube Channel
Algorithm Design Manual by Steven Skiena
Elements of Programming Interviews

This comprehensive guide combines theoretical understanding with practical problem-solving, providing a solid foundation for mastering two pointers and sliding window techniques.