# Sliding Window Maximum : Set 2

• Difficulty Level : Medium
• Last Updated : 06 Aug, 2021

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:

Become a success story instead of just reading about them. Prepare for coding interviews at Amazon and other top product-based companies with our Amazon Test Series. Includes topic-wise practice questions on all important DSA topics along with 10 practice contests of 2 hours each. Designed by industry experts that will surely help you practice and sharpen your programming skills. Wait no more, start your preparation today!

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 ` `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);` `    ``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``;` `            ``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#

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

 ``

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

## 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 `

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

 ``

Output

`3 4 5 6 7 8 9 10 `

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :