Sliding Window Maximum : Set 2

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 ccontigious 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.

  • First variable pointer iterates through the subarray and finds maximum element from given size K
  • 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 second variable pointer, maximum of that subarray has been computed and will be printed.
  • The process is repeated until second variable pointer reach last array index (i.e array_size – 1).

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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, prall 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;
  
            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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

3 4 5 6 7 8 9 10

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.