🔍 Sliding Window Technique in Java – The Ultimate Guide 🚪

Sliding Window is a powerful technique used for solving problems that involve arrays or strings where you need to examine contiguous subarrays (or substrings) efficiently.

It helps reduce O(n²) time complexity to O(n) in many scenarios.

---

🧠 What is the Sliding Window Technique?

The Sliding Window technique involves moving a window (range) over your input data structure to track a subset of elements that satisfy a condition — such as sum, max/min, or uniqueness.

There are two types:

• Fixed-size Window (size is constant)
• Variable-size Window (size grows or shrinks based on conditions)

---

🔥 When to Use It?

✅ Subarray or substring problems

✅ Optimize brute-force nested loops

✅ Continuous or sliding segment problems

✅ Max/min/avg/sum/unique patterns

---

✨ Sliding Window Templates

🧩 Fixed-size window

for (int i = 0; i < n; i++) {
    // Expand the window
    window.add(nums[i]);

    // Once window size is reached
    if (i >= k - 1) {
        result = ... // Do something
        window.remove(nums[i - k + 1]); // Slide the window
    }
}

---

🧩 Variable-size window

int left = 0;

for (int right = 0; right < n; right++) {
    // Expand to right

    while (condition is violated) {
        // Shrink from left
        left++;
    }

    // Update answer if needed
}

---

🔨 Java Code Examples

---

📘 1. Maximum Sum Subarray of Size K

public int maxSum(int[] nums, int k) {
    int max = 0, windowSum = 0;

    for (int i = 0; i < nums.length; i++) {
        windowSum += nums[i];

        if (i >= k - 1) {
            max = Math.max(max, windowSum);
            windowSum -= nums[i - k + 1];
        }
    }
    return max;
}

🧠 Fixed-size sliding window

⏱ Time: O(n)

---

📘 2. Longest Substring Without Repeating Characters

public int lengthOfLongestSubstring(String s) {
    Set<Character> set = new HashSet<>();
    int left = 0, max = 0;

    for (int right = 0; right < s.length(); right++) {
        while (set.contains(s.charAt(right))) {
            set.remove(s.charAt(left++));
        }
        set.add(s.charAt(right));
        max = Math.max(max, right - left + 1);
    }

    return max;
}

🧠 Variable-size window

⏱ Time: O(n)

---

📘 3. Minimum Size Subarray Sum

Given nums[] and target, find the minimum length of subarray whose sum ≥ target.

public int minSubArrayLen(int target, int[] nums) {
    int left = 0, sum = 0, minLen = Integer.MAX_VALUE;

    for (int right = 0; right < nums.length; right++) {
        sum += nums[right];

        while (sum >= target) {
            minLen = Math.min(minLen, right - left + 1);
            sum -= nums[left++];
        }
    }
    return minLen == Integer.MAX_VALUE ? 0 : minLen;
}

🧠 Shrinking window when condition met

⏱ Time: O(n)

---

📘 4. Longest Repeating Character Replacement

Replace at most k characters to get the longest substring with the same character.

public int characterReplacement(String s, int k) {
    int[] count = new int[26];
    int left = 0, maxFreq = 0, maxLen = 0;

    for (int right = 0; right < s.length(); right++) {
        count[s.charAt(right) - 'A']++;
        maxFreq = Math.max(maxFreq, count[s.charAt(right) - 'A']);

        while (right - left + 1 - maxFreq > k) {
            count[s.charAt(left++) - 'A']--;
        }

        maxLen = Math.max(maxLen, right - left + 1);
    }

    return maxLen;
}

---

🧮 Time & Space Complexity

Problem	Time Complexity	Space Complexity
Max sum subarray	O(n)	O(1)
Longest substring w/o repeats	O(n)	O(n)
Min subarray sum ≥ target	O(n)	O(1)

---

📦 Comparison with Brute Force

Brute-force	Sliding Window
O(n²)	O(n)
Inefficient	Optimal
Nested loops	Single loop

---

💡 Real Interview Problems That Use It

Problem	Platform
Longest Substring Without Repeating	LeetCode 3
Minimum Window Substring	LeetCode 76
Sliding Window Maximum	LeetCode 239
Permutation in String	LeetCode 567
Longest Repeating Char Replacement	LeetCode 424

---

🎯 Final Words

The Sliding Window technique is a must-know for any aspiring software engineer. It turns brute-force time-consuming solutions into sleek and elegant O(n) solutions. 🚀

---

🔁 Related Concepts

• Two Pointer Technique 🏃‍♂️🏃‍♀️
• Prefix Sum
• Monotonic Queue
• HashMap and Frequency Counters

---