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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

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

C#

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

Output:

3 4 5 6 7 8 9 10

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

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#

Recommended Posts: