GeeksforGeeks App
Open App
Browser
Continue

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

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

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

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