# Sliding Window Maximum (Maximum of all subarrays of size k)

Given an array and an integer K, 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

Input: arr[] = {8, 5, 10, 7, 9, 4, 15, 12, 90, 13}, K = 4
Output: 10 10 10 15 15 90 90

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Method 1 (Simple)
Run two loops. In the outer loop, take all subarrays of size K. In the inner loop, get the maximum of the current subarray.

## C++

 `// C++ Program to find the maximum for  ` `// each and every contiguous subarray of size k. ` `#include ` `using` `namespace` `std; ` ` `  `// Method to find the maximum for each  ` `// and every contiguous subarray of size k. ` `void` `printKMax(``int` `arr[], ``int` `n, ``int` `k)  ` `{  ` `    ``int` `j, max;  ` ` `  `    ``for` `(``int` `i = 0; i <= n - k; i++)  ` `    ``{  ` `        ``max = arr[i];  ` ` `  `        ``for` `(j = 1; j < k; j++)  ` `        ``{  ` `            ``if` `(arr[i + j] > max)  ` `                ``max = arr[i + j];  ` `        ``}  ` `        ``cout << max << ``" "``;  ` `    ``}  ` `}  ` ` `  `// Driver code ` `int` `main()  ` `{  ` `    ``int` `arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);  ` `    ``int` `k = 3;  ` `    ``printKMax(arr, n, k);  ` `    ``return` `0;  ` `} ` ` `  `// This code is contributed by rathbhupendra `

## C

 `#include ` ` `  `void` `printKMax(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``int` `j, max; ` ` `  `    ``for` `(``int` `i = 0; i <= n - k; i++) { ` `        ``max = arr[i]; ` ` `  `        ``for` `(j = 1; j < k; j++) { ` `            ``if` `(arr[i + j] > max) ` `                ``max = arr[i + j]; ` `        ``} ` `        ``printf``(``"%d "``, max); ` `    ``} ` `} ` ` `  `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `k = 3; ` `    ``printKMax(arr, n, k); ` `    ``return` `0; ` `}`

## Java

 `// Java Program to find the maximum for each and every contiguous subarray of size k. ` ` `  `public` `class` `GFG { ` `    ``// Method to find the maximum for each and every contiguous subarray of size k. ` `    ``static` `void` `printKMax(``int` `arr[], ``int` `n, ``int` `k) ` `    ``{ ` `        ``int` `j, max; ` ` `  `        ``for` `(``int` `i = ``0``; i <= n - k; i++) { ` ` `  `            ``max = arr[i]; ` ` `  `            ``for` `(j = ``1``; j < k; j++) { ` `                ``if` `(arr[i + j] > max) ` `                    ``max = arr[i + j]; ` `            ``} ` `            ``System.out.print(max + ``" "``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver method ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``, ``10` `}; ` `        ``int` `k = ``3``; ` `        ``printKMax(arr, arr.length, k); ` `    ``} ` `} ` ` `  `// This code is contributed by Sumit Ghosh `

## Python3

 `# Python program to find the maximum for  ` `# each and every contiguous subarray of ` `# size k ` ` `  `# Method to find the maximum for each ` `# and every contiguous subarray of s  ` `# of size k ` `def` `printMax(arr, n, k): ` `    ``max` `=` `0` `   `  `    ``for` `i ``in` `range``(n ``-` `k ``+` `1``): ` `        ``max` `=` `arr[i] ` `        ``for` `j ``in` `range``(``1``, k): ` `            ``if` `arr[i ``+` `j] > ``max``: ` `                ``max` `=` `arr[i ``+` `j] ` `        ``print``(``str``(``max``) ``+` `" "``, end ``=` `"") ` ` `  `# Driver method ` `if` `__name__``=``=``"__main__"``: ` `    ``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``, ``10``] ` `    ``n ``=` `len``(arr) ` `    ``k ``=` `3` `    ``printMax(arr, n, k) ` ` `  `# This code is contributed by Shiv Shankar  `

## C#

 `// C# program to find the maximum for ` `// each and every contiguous subarray of ` `// size kusing System; ` `using` `System; ` ` `  `class` `GFG { ` `    ``// Method to find the maximum for ` `    ``// each and every contiguous subarray ` `    ``// of size k. ` `    ``static` `void` `printKMax(``int``[] arr, ``int` `n, ``int` `k) ` `    ``{ ` `        ``int` `j, max; ` ` `  `        ``for` `(``int` `i = 0; i <= n - k; i++) { ` ` `  `            ``max = arr[i]; ` ` `  `            ``for` `(j = 1; j < k; j++) { ` `                ``if` `(arr[i + j] > max) ` `                    ``max = arr[i + j]; ` `            ``} ` `            ``Console.Write(max + ``" "``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver method ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; ` `        ``int` `k = 3; ` `        ``printKMax(arr, arr.Length, k); ` `    ``} ` `} ` ` `  `// This Code is Contributed by Sam007 `

## PHP

 ` ``\$max``) ` `            ``\$max` `= ``\$arr``[``\$i` `+ ``\$j``]; ` `        ``} ` `        ``printf(``"%d "``, ``\$max``); ` `    ``} ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(1, 2, 3, 4, 5,  ` `             ``6, 7, 8, 9, 10); ` `\$n` `= ``count``(``\$arr``); ` `\$k` `= 3; ` `printKMax(``\$arr``, ``\$n``, ``\$k``); ` ` `  `// This Code is Contributed by anuj_67. ` `?> `

Output:

```3 4 5 6 7 8 9 10
```

Time Complexity : The outer loop runs n-k+1 times and the inner loop runs k times for every iteration of outer loop. So time complexity is O((n-k+1)*k) which can also be written as O(N * K).

Method 2 (Use Self-Balancing BST)

• Pick first k elements and create a Self-Balancing Binary Search Tree (BST) of size k.
• Run a loop for i = 0 to n – k
1. Get the maximum element from the BST, and print it.
2. Search for arr[i] in the BST and delete it from the BST.
3. Insert arr[i+k] into the BST.

Time Complexity: Time Complexity of step 1 is O(K * Log k). Time Complexity of steps 2(a), 2(b) and 2(c) is O(Logk). Since steps 2(a), 2(b) and 2(c) are in a loop that runs n-k+1 times, time complexity of the complete algorithm is O(kLogk + (n-k+1)*Logk) which can also be written as O(N * Log k).

Method 3 (A O(n) method: use Deque) We create a Deque, Qi of capacity k, that stores only useful elements of current window of k elements. An element is useful if it is in current window and is greater than all other elements on left side of it in current window. We process all array elements one by one and maintain Qi to contain useful elements of current window and these useful elements are maintained in sorted order. The element at front of the Qi is the largest and element at rear of Qi is the smallest of current window. Thanks to Aashish for suggesting this method.

Below image is a dry run of the above approach: Below is the implementation of the above approach.

## C++

 `#include ` `#include ` ` `  `using` `namespace` `std; ` ` `  `// A Dequeue (Double ended queue) based method for printing maximum element of ` `// all subarrays of size k ` `void` `printKMax(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``// Create a Double Ended Queue, Qi that will store indexes of array elements ` `    ``// The queue will store indexes of useful elements in every window and it will ` `    ``// maintain decreasing order of values from front to rear in Qi, i.e., ` `    ``// arr[Qi.front[]] to arr[Qi.rear()] are sorted in decreasing order ` `    ``std::deque<``int``> Qi(k); ` ` `  `    ``/* Process first k (or first window) elements of array */` `    ``int` `i; ` `    ``for` `(i = 0; i < k; ++i) { ` `        ``// For every element, the previous smaller elements are useless so ` `        ``// remove them from Qi ` `        ``while` `((!Qi.empty()) && arr[i] >= arr[Qi.back()]) ` `            ``Qi.pop_back(); ``// Remove from rear ` ` `  `        ``// Add new element at rear of queue ` `        ``Qi.push_back(i); ` `    ``} ` ` `  `    ``// Process rest of the elements, i.e., from arr[k] to arr[n-1] ` `    ``for` `(; i < n; ++i) { ` `        ``// The element at the front of the queue is the largest element of ` `        ``// previous window, so print it ` `        ``cout << arr[Qi.front()] << ``" "``; ` ` `  `        ``// Remove the elements which are out of this window ` `        ``while` `((!Qi.empty()) && Qi.front() <= i - k) ` `            ``Qi.pop_front(); ``// Remove from front of queue ` ` `  `        ``// Remove all elements smaller than the currently ` `        ``// being added element (remove useless elements) ` `        ``while` `((!Qi.empty()) && arr[i] >= arr[Qi.back()]) ` `            ``Qi.pop_back(); ` ` `  `        ``// Add current element at the rear of Qi ` `        ``Qi.push_back(i); ` `    ``} ` ` `  `    ``// Print the maximum element of last window ` `    ``cout << arr[Qi.front()]; ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `arr[] = { 12, 1, 78, 90, 57, 89, 56 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `k = 3; ` `    ``printKMax(arr, n, k); ` `    ``return` `0; ` `} `

## Java

 `// Java Program to find the maximum for  ` `// each and every contiguous subarray of size k. ` ` `  `import` `java.util.Deque; ` `import` `java.util.LinkedList; ` ` `  `public` `class` `SlidingWindow { ` ` `  `    ``// A Dequeue (Double ended queue) based method for printing maximum element of ` `    ``// all subarrays of size k ` `    ``static` `void` `printMax(``int` `arr[], ``int` `n, ``int` `k) ` `    ``{ ` `        ``// Create a Double Ended Queue, Qi that will store indexes of array elements ` `        ``// The queue will store indexes of useful elements in every window and it will ` `        ``// maintain decreasing order of values from front to rear in Qi, i.e., ` `        ``// arr[Qi.front[]] to arr[Qi.rear()] are sorted in decreasing order ` `        ``Deque Qi = ``new` `LinkedList(); ` ` `  `        ``/* Process first k (or first window) elements of array */` `        ``int` `i; ` `        ``for` `(i = ``0``; i < k; ++i) { ` `            ``// For every element, the previous smaller elements are useless so ` `            ``// remove them from Qi ` `            ``while` `(!Qi.isEmpty() && arr[i] >= arr[Qi.peekLast()]) ` `                ``Qi.removeLast(); ``// Remove from rear ` ` `  `            ``// Add new element at rear of queue ` `            ``Qi.addLast(i); ` `        ``} ` ` `  `        ``// Process rest of the elements, i.e., from arr[k] to arr[n-1] ` `        ``for` `(; i < n; ++i) { ` `            ``// The element at the front of the queue is the largest element of ` `            ``// previous window, so print it ` `            ``System.out.print(arr[Qi.peek()] + ``" "``); ` ` `  `            ``// Remove the elements which are out of this window ` `            ``while` `((!Qi.isEmpty()) && Qi.peek() <= i - k) ` `                ``Qi.removeFirst(); ` ` `  `            ``// Remove all elements smaller than the currently ` `            ``// being added element (remove useless elements) ` `            ``while` `((!Qi.isEmpty()) && arr[i] >= arr[Qi.peekLast()]) ` `                ``Qi.removeLast(); ` ` `  `            ``// Add current element at the rear of Qi ` `            ``Qi.addLast(i); ` `        ``} ` ` `  `        ``// Print the maximum element of last window ` `        ``System.out.print(arr[Qi.peek()]); ` `    ``} ` ` `  `    ``// Driver program to test above functions ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``12``, ``1``, ``78``, ``90``, ``57``, ``89``, ``56` `}; ` `        ``int` `k = ``3``; ` `        ``printMax(arr, arr.length, k); ` `    ``} ` `} ` `// This code is contributed by Sumit Ghosh `

## Python3

 `# Python program to find the maximum for  ` `# each and every contiguous subarray of ` `# size k ` ` `  `from` `collections ``import` `deque ` ` `  `# A Deque (Double ended queue) based  ` `# method for printing maximum element  ` `# of all subarrays of size k  ` `def` `printMax(arr, n, k): ` `     `  `    ``""" Create a Double Ended Queue, Qi that  ` `    ``will store indexes of array elements.  ` `    ``The queue will store indexes of useful  ` `    ``elements in every window and it will ` `    ``maintain decreasing order of values from ` `    ``front to rear in Qi, i.e., arr[Qi.front[]] ` `    ``to arr[Qi.rear()] are sorted in decreasing ` `    ``order"""` `    ``Qi ``=` `deque() ` `     `  `    ``# Process first k (or first window)  ` `    ``# elements of array ` `    ``for` `i ``in` `range``(k): ` `       `  `        ``# For every element, the previous  ` `        ``# smaller elements are useless ` `        ``# so remove them from Qi ` `        ``while` `Qi ``and` `arr[i] >``=` `arr[Qi[``-``1``]] : ` `            ``Qi.pop() ` `         `  `        ``# Add new element at rear of queue ` `        ``Qi.append(i); ` `         `  `    ``# Process rest of the elements, i.e.  ` `    ``# from arr[k] to arr[n-1] ` `    ``for` `i ``in` `range``(k, n): ` `         `  `        ``# The element at the front of the ` `        ``# queue is the largest element of ` `        ``# previous window, so print it ` `        ``print``(``str``(arr[Qi[``0``]]) ``+` `" "``, end ``=` `"") ` `         `  `        ``# Remove the elements which are  ` `        ``# out of this window ` `        ``while` `Qi ``and` `Qi[``0``] <``=` `i``-``k: ` `             `  `            ``# remove from front of deque ` `            ``Qi.popleft()  ` `         `  `        ``# Remove all elements smaller than ` `        ``# the currently being added element  ` `        ``# (Remove useless elements) ` `        ``while` `Qi ``and` `arr[i] >``=` `arr[Qi[``-``1``]] : ` `            ``Qi.pop() ` `         `  `        ``# Add current element at the rear of Qi ` `        ``Qi.append(i) ` `     `  `    ``# Print the maximum element of last window ` `    ``print``(``str``(arr[Qi[``0``]])) ` `     `  `# Driver programm to test above fumctions ` `if` `__name__``=``=``"__main__"``: ` `    ``arr ``=` `[``12``, ``1``, ``78``, ``90``, ``57``, ``89``, ``56``] ` `    ``k ``=` `3` `    ``printMax(arr, ``len``(arr), k) ` `     `  `# This code is contributed by Shiv Shankar  `

## C#

 `// C# Program to find the maximum for each  ` `// and every contiguous subarray of size k. ` `using` `System;  ` `using` `System.Collections.Generic; ` ` `  `public` `class` `SlidingWindow  ` `{ ` ` `  `    ``// A Dequeue (Double ended queue) based  ` `    ``// method for printing maximum element of ` `    ``// all subarrays of size k ` `    ``static` `void` `printMax(``int` `[]arr, ``int` `n, ``int` `k) ` `    ``{ ` `        ``// Create a Double Ended Queue, Qi that  ` `        ``// will store indexes of array elements ` `        ``// The queue will store indexes of useful  ` `        ``// elements in every window and it will ` `        ``// maintain decreasing order of values  ` `        ``// from front to rear in Qi, i.e., ` `        ``// arr[Qi.front[]] to arr[Qi.rear()]  ` `        ``// are sorted in decreasing order ` `        ``List<``int``> Qi = ``new` `List<``int``>(); ` ` `  `        ``/* Process first k (or first window) elements of array */` `        ``int` `i; ` `        ``for` `(i = 0; i < k; ++i) { ` `            ``// For every element, the previous  ` `            ``// smaller elements are useless so ` `            ``// remove them from Qi ` `            ``while` `(Qi.Count != 0 && arr[i] >= arr[Qi.IndexOf(0)]) ` `                ``Qi.RemoveAt(Qi.Count-1); ``// Remove from rear ` ` `  `            ``// Add new element at rear of queue ` `            ``Qi.Insert(Qi.Count, i); ` `        ``} ` ` `  `        ``// Process rest of the elements,  ` `        ``// i.e., from arr[k] to arr[n-1] ` `        ``for` `(; i < n; ++i)  ` `        ``{ ` `            ``// The element at the front of  ` `            ``// the queue is the largest element of ` `            ``// previous window, so print it ` `            ``Console.Write(arr[Qi] + ``" "``); ` ` `  `            ``// Remove the elements which are out of this window ` `            ``while` `((Qi.Count != 0) && Qi <= i - k) ` `                ``Qi.RemoveAt(0); ` ` `  `            ``// Remove all elements smaller than the currently ` `            ``// being added element (remove useless elements) ` `            ``while` `((Qi.Count != 0) && arr[i] >= arr[Qi[Qi.Count - 1]]) ` `                ``Qi.RemoveAt(Qi.Count - 1); ` ` `  `            ``// Add current element at the rear of Qi ` `            ``Qi.Insert(Qi.Count, i); ` `        ``} ` ` `  `        ``// Print the maximum element of last window ` `        ``Console.Write(arr[Qi]); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `[]arr = { 12, 1, 78, 90, 57, 89, 56 }; ` `        ``int` `k = 3; ` `        ``printMax(arr, arr.Length, k); ` `    ``} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

Output:

```78 90 90 90 89
```

Output:

`78 90 90 90 89`

Below is an extension of this problem.
Sum of minimum and maximum elements of all subarrays of size k.

Time Complexity: O(n). It seems more than O(n) at first look. If we take a closer look, we can observe that every element of array is added and removed at most once. So there are total 2n operations.
Auxiliary Space: O(k)

Method 4 (Use Max-Heap)

1. Pick first k elements and create a max heap of size k.
2. Perform heapify and print the root element.
3. Store the next and last element from the array
4. Run a loop from k – 1 to n
• Replace the value of element which is got out of the window with new element which came inside the window.
• Perform heapify.
• Print the root of the Heap.

Time Complexity: Time Complexity of steps 4(a) is O(k), 4(b) is O(Log(k)) and it is in a loop that runs (n – k + 1) times. Hence, the time complexity of the complete algorithm is O((k + Log(k)) * n) i.e. O(n * k).

## Python3

 `# Python program to find the maximum for  ` `# each and every contiguous subarray of ` `# size k  ` `import` `heapq ` ` `  `# Method to find the maximum for each ` `# and every contiguous subarray of s  ` `# of size k ` `def` `max_of_all_in_k(arr, n): ` `    ``i ``=` `0` `    ``j ``=` `k``-``1` `     `  `    ``# Create the heap and heapify ` `    ``heap ``=` `arr[i:j ``+` `1``] ` `    ``heapq._heapify_max(heap) ` `     `  `    ``# Print the maximum element from  ` `    ``# the first window of size k ` `    ``print``(heap[``0``], end ``=``" "``) ` `    ``last ``=` `arr[i] ` `    ``i``+``=` `1` `    ``j``+``=` `1` `    ``nexts ``=` `arr[j] ` `     `  `    ``# For every remaining element ` `    ``while` `j < n: ` `         `  `        ``# Add the next element of the window ` `        ``heap[heap.index(last)] ``=` `nexts ` `         `  `        ``# Heapify to get the maximum  ` `        ``# of the current window ` `        ``heapq._heapify_max(heap) ` `         `  `        ``# Print the current maximum ` `        ``print``(heap[``0``], end ``=``" "``) ` `        ``last ``=` `arr[i] ` `        ``i``+``=` `1` `        ``j``+``=` `1` `        ``if` `j < n: ` `            ``nexts ``=` `arr[j] ` `             `  `# Driver Function ` `n, k ``=` `10``, ``3` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``, ``10``] ` `max_of_all_in_k(arr, n) `

Output:

```3 4 5 6 7 8 9 10
```

Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.

My Personal Notes arrow_drop_up