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} => 6Input: 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++
// 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
filter_none
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 |
chevron_right
filter_none
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; 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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
Output:
3 4 5 6 7 8 9 10
Time Complexity: O(N*k)
Auxiliary Space Complexity: O(1)
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
