Sliding Window Maximum : Set 2

Last Updated : 12 Jul, 2025

Set 1: Sliding Window Maximum (Maximum of all subarrays of size k).
Given an array arr of size N and an integer K, the task is to find the maximum for each and every contiguous subarray of size K.

Examples:

Input: arr[] = {1, 2, 3, 1, 4, 5, 2, 3, 6}, K = 3
Output: 3 3 4 5 5 5 6
All contiguous subarrays of size k are
{1, 2, 3} => 3
{2, 3, 1} => 3
{3, 1, 4} => 4
{1, 4, 5} => 5
{4, 5, 2} => 5
{5, 2, 3} => 5
{2, 3, 6} => 6

Input: arr[] = {8, 5, 10, 7, 9, 4, 15, 12, 90, 13}, K = 4
Output: 10 10 10 15 15 90 90

Approach: To solve this in lesser space complexity we can use two pointer technique.

The first variable pointer iterates through the subarray and finds the maximum element of a given size K
The second variable pointer marks the ending index of the first variable pointer i.e., (i + K - 1)th index.
When the first variable pointer reaches the index of the second variable pointer, the maximum of that subarray has been computed and will be printed.
The process is repeated until the second variable pointer reaches the last array index (i.e array_size - 1).

Below is the implementation of the above approach:

C++

// C++ program to find the maximum for each
// and every contiguous subarray of size K

#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum for each
// and every contiguous subarray of size k
void printKMax(int a[], int n, int k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (int i = 0; i < n; i += 1)
            cout << a[i] << " ";
        return;
    }

    // Using p and q as variable pointers
    // where p iterates through the subarray
    // and q marks end of the subarray.
    int p = 0,
        q = k - 1,
        t = p,
        max = a[k - 1];

    // Iterating through subarray.
    while (q <= n - 1) {

        // Finding max
        // from the subarray.
        if (a[p] > max)
            max = a[p];

        p += 1;

        // Printing max of subarray
        // and shifting pointers
        // to next index.
        if (q == p && p != n) {
            cout << max << " ";
            q++;
            p = ++t;

            if (q < n)
                max = a[q];
        }
    }
}

// Driver Code
int main()
{
    int a[] = { 1, 2, 3, 4, 5,
                6, 7, 8, 9, 10 };
    int n = sizeof(a) / sizeof(a[0]);
    int K = 3;

    printKMax(a, n, K);

    return 0;
}

Java

// Java program to find the maximum for each
// and every contiguous subarray of size K
import java.util.*;

class GFG{
 
// Function to find the maximum for each
// and every contiguous subarray of size k
static void printKMax(int a[], int n, int k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (int i = 0; i < n; i += 1)
            System.out.print(a[i]+ " ");
        return;
    }
 
    // Using p and q as variable pointers
    // where p iterates through the subarray
    // and q marks end of the subarray.
    int p = 0,
        q = k - 1,
        t = p,
        max = a[k - 1];
 
    // Iterating through subarray.
    while (q <= n - 1) {
 
        // Finding max
        // from the subarray.
        if (a[p] > max)
            max = a[p];
 
        p += 1;
 
        // Printing max of subarray
        // and shifting pointers
        // to next index.
        if (q == p && p != n) {
            System.out.print(max+ " ");
            q++;
            p = ++t;
 
            if (q < n)
                max = a[q];
        }
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int a[] = { 1, 2, 3, 4, 5,
                6, 7, 8, 9, 10 };
    int n = a.length;
    int K = 3;
 
    printKMax(a, n, K);
}
}

// This code is contributed by 29AjayKumar

Python3

# Python3 program to find the maximum for each
# and every contiguous subarray of size K

# Function to find the maximum for each
# and every contiguous subarray of size k
def printKMax(a, n, k):
    
    # If k = 1, print all elements
    if (k == 1):
        for i in range(n):
            print(a[i], end=" ");
        return;
        
    # Using p and q as variable pointers
    # where p iterates through the subarray
    # and q marks end of the subarray.
    p = 0;
    q = k - 1;
    t = p;
    max = a[k - 1];

    # Iterating through subarray.
    while (q <= n - 1):

        # Finding max
        # from the subarray.
        if (a[p] > max):
            max = a[p];
        p += 1;

        # Printing max of subarray
        # and shifting pointers
        # to next index.
        if (q == p and p != n):
            print(max, end=" ");
            q += 1;
            p = t + 1;
            t = p;

            if (q < n):
                max = a[q];

# Driver Code
if __name__ == '__main__':
    a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    n = len(a);
    K = 3;

    printKMax(a, n, K);

# This code is contributed by Princi Singh

// C# program to find the maximum for each
// and every contiguous subarray of size K
using System;

class GFG{
  
// Function to find the maximum for each
// and every contiguous subarray of size k
static void printKMax(int []a, int n, int k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (int i = 0; i < n; i += 1)
            Console.Write(a[i]+ " ");
        return;
    }
  
    // Using p and q as variable pointers
    // where p iterates through the subarray
    // and q marks end of the subarray.
    int p = 0,
        q = k - 1,
        t = p,
        max = a[k - 1];
  
    // Iterating through subarray.
    while (q <= n - 1) {
  
        // Finding max
        // from the subarray.
        if (a[p] > max)
            max = a[p];
  
        p += 1;
  
        // Printing max of subarray
        // and shifting pointers
        // to next index.
        if (q == p && p != n) {
            Console.Write(max+ " ");
            q++;
            p = ++t;
  
            if (q < n)
                max = a[q];
        }
    }
}
  
// Driver Code
public static void Main(String[] args)
{
    int []a = { 1, 2, 3, 4, 5,
                6, 7, 8, 9, 10 };
    int n = a.Length;
    int K = 3;
  
    printKMax(a, n, K);
}
}
 
// This code is contributed by Rajput-Ji

JavaScript

<script>
// Javascript program to find the maximum for each
// and every contiguous subarray of size K

// Function to find the maximum for each
// and every contiguous subarray of size k
function printKMax(a, n, k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (let i = 0; i < n; i += 1)
            document.write(a[i] + " ");
        return;
    }

    // Using p and q as variable pointers
    // where p iterates through the subarray
    // and q marks end of the subarray.
    let p = 0, q = k - 1, t = p, max = a[k - 1];

    // Iterating through subarray.
    while (q <= n - 1) {

        // Finding max
        // from the subarray.
        if (a[p] > max)
            max = a[p];

        p += 1;

        // Printing max of subarray
        // and shifting pointers
        // to next index.
        if (q == p && p != n) {
            document.write(max + " ");
            q++;
            p = ++t;

            if (q < n)
                max = a[q];
        }
    }
}

// Driver Code

let a = [ 1, 2, 3, 4, 5,
            6, 7, 8, 9, 10 ];
let n = a.length
let K = 3;

printKMax(a, n, K);
</script>

Output

3 4 5 6 7 8 9 10

Time Complexity: O(N*k)
Auxiliary Space Complexity: O(1)

Approach 2: Using Dynamic Programming:

Firstly, divide the entire array into blocks of k elements such that each block contains k elements of the array(not always for the last block).
Maintain two dp arrays namely, left and right.
left[i] is the maximum of all elements that are to the left of current element(including current element) in the current block(block in which current element is present).
Similarly, right[i] is the maximum of all elements that are to the right of current element(including current element) in the current block(block in which current element is present).
Finally, when calculating the maximum element in any subarray of length k, we calculate the maximum of right[l] and left[r]
where l = starting index of current sub array, r = ending index of current sub array

Below is the implementation of above approach,

C++

// C++ program to find the maximum for each
// and every contiguous subarray of size K

#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum for each
// and every contiguous subarray of size k
void printKMax(int a[], int n, int k)
{
    // If k = 1, print all elements
    if (k == 1) {
        for (int i = 0; i < n; i += 1)
            cout << a[i] << " ";
        return;
    }
    
      //left[i] stores the maximum value to left of i in the current block
      //right[i] stores the maximum value to the right of i in the current block
    int left[n],right[n];
  
      for(int i=0;i<n;i++){
          //if the element is starting element of that block
        if(i%k == 0) left[i] = a[i];
          else left[i] = max(left[i-1],a[i]);
          
          //if the element is ending element of that block
          if((n-i)%k == 0 || i==0) right[n-1-i] = a[n-1-i];
          else right[n-1-i] = max(right[n-i],a[n-1-i]);
    }
  
      for(int i=0,j=k-1; j<n; i++,j++) 
         cout << max(left[j],right[i]) << ' ';
}

// Driver Code
int main()
{
    int a[] = { 1, 2, 3, 4, 5,
                6, 7, 8, 9, 10 };
    int n = sizeof(a) / sizeof(a[0]);
    int K = 3;

    printKMax(a, n, K);

    return 0;
}

Java

// Java program to find the maximum for each
// and every contiguous subarray of size K
import java.util.*;

class GFG 
{

  // Function to find the maximum for each
  // and every contiguous subarray of size k
  static void printKMax(int a[], int n, int k) 
  {

    // If k = 1, print all elements
    if (k == 1) {
      for (int i = 0; i < n; i += 1)
        System.out.print(a[i] + " ");
      return;
    }

    // left[i] stores the maximum value to left of i in the current block
    // right[i] stores the maximum value to the right of i in the current block
    int left[] = new int[n];
    int right[] = new int[n];

    for (int i = 0; i < n; i++)
    {

      // if the element is starting element of that block
      if (i % k == 0)
        left[i] = a[i];
      else
        left[i] = Math.max(left[i - 1], a[i]);

      // if the element is ending element of that block
      if ((n - i) % k == 0 || i == 0)
        right[n - 1 - i] = a[n - 1 - i];
      else
        right[n - 1 - i] = Math.max(right[n - i], a[n - 1 - i]);
    }

    for (int i = 0, j = k - 1; j < n; i++, j++)
      System.out.print(Math.max(left[j], right[i]) + " ");
  }

  // Driver Code
  public static void main(String[] args)
  {
    int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int n = a.length;
    int K = 3;

    printKMax(a, n, K);

  }
}

// This code is contributed by gauravrajput1

Python3

# Python3 program to find the maximum for each
# and every contiguous subarray of size K
# Function to find the maximum for each
# and every contiguous subarray of size k
def printKMax(a, n, k):

    # If k = 1, print all elements
    if (k == 1):
        for i in range(n):
            print(a[i],end = " ")
        return

    # left[i] stores the maximum value to left of i in the current block
    # right[i] stores the maximum value to the right of i in the current block
    left = [ 0 for i in range(n)]
    right = [ 0 for i in range(n)]

    for i in range(n):

        # if the element is starting element of that block
        if (i % k == 0):
            left[i] = a[i]
        else:
            left[i] = max(left[i - 1], a[i])

        # if the element is ending element of that block
        if ((n - i) % k == 0 or i == 0):
            right[n - 1 - i] = a[n - 1 - i]
        else:
            right[n - 1 - i] = max(right[n - i], a[n - 1 - i])

    i = 0
    j = k - 1

    while j < n:
        print(max(left[j], right[i]),end = " ")
        i += 1
        j += 1

# Driver Code
a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
n = len(a)
K = 3

printKMax(a, n, K)

# This code is contributed by shinjanpatra

// C# program to find the maximum for each
// and every contiguous subarray of size K
using System;

class GFG 
{

  // Function to find the maximum for each
  // and every contiguous subarray of size k
  static void printKMax(int []a, int n, int k) 
  {

    // If k = 1, print all elements
    if (k == 1) {
      for (int i = 0; i < n; i += 1)
        Console.Write(a[i] + " ");
      return;
    }

    // left[i] stores the maximum value to left of i in the current block
    // right[i] stores the maximum value to the right of i in the current block
    int []left = new int[n];
    int []right = new int[n];

    for (int i = 0; i < n; i++)
    {

      // if the element is starting element of that block
      if (i % k == 0)
        left[i] = a[i];
      else
        left[i] = Math.Max(left[i - 1], a[i]);

      // if the element is ending element of that block
      if ((n - i) % k == 0 || i == 0)
        right[n - 1 - i] = a[n - 1 - i];
      else
        right[n - 1 - i] = Math.Max(right[n - i], a[n - 1 - i]);
    }

    for (int i = 0, j = k - 1; j < n; i++, j++)
      Console.Write(Math.Max(left[j], right[i]) + " ");
  }

  // Driver Code
  public static void Main(String[] args)
  {
    int []a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int n = a.Length;
    int K = 3;

    printKMax(a, n, K);

  }
}

// This code is contributed by shivanisinghss2110

JavaScript

<script>

// JavaScript program to find the maximum for each
// and every contiguous subarray of size K
// Function to find the maximum for each
// and every contiguous subarray of size k
function printKMax(a, n, k) 
  {

    // If k = 1, print all elements
    if (k == 1) {
      for (var i = 0; i < n; i += 1)
        document.write(a[i] + " ");
      return;
    }

    // left[i] stores the maximum value to left of i in the current block
    // right[i] stores the maximum value to the right of i in the current block
    var left = [n];
    var right = [n];

    for (var i = 0; i < n; i++)
    {

      // if the element is starting element of that block
      if (i % k == 0)
        left[i] = a[i];
      else
        left[i] = Math.max(left[i - 1], a[i]);

      // if the element is ending element of that block
      if ((n - i) % k == 0 || i == 0)
        right[n - 1 - i] = a[n - 1 - i];
      else
        right[n - 1 - i] = Math.max(right[n - i], a[n - 1 - i]);
    }

    for (var i = 0, j = k - 1; j < n; i++, j++)
      document.write(Math.max(left[j], right[i]) + " ");
  }

  // Driver Code
    var a = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ];
    var n = a.length;
    var K = 3;

    printKMax(a, n, K);

// This code is contributed by shivanisinghss2110 

</script>

Output

3 4 5 6 7 8 9 10

Time Complexity : O(n)
Auxiliary Space : O(n)

Analysis of Algorithms

yashbeersingh42

Improve

Article Tags :

Practice Tags :

Sliding Window Maximum : Set 2

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?