# 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
Explanation: Maximum of 1, 2, 3 is 3
Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Maximum of 2, 3, 1 is 3
Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Maximum of 3, 1, 4 is 4
Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Maximum of 1, 4, 5 is 5
Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Maximum of 4, 5, 2 is 5Â
Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Maximum of 5, 2, 3 is 5
Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Maximum of 2, 3, 6 is 6

Input: arr[] = {8, 5, 10, 7, 9, 4, 15, 12, 90, 13}, K = 4Â
Output: 10 10 10 15 15 90 90 Â  Â  Â  Â  Â
Explanation: Maximum of first 4 elements is 10, similarly for next 4Â
Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â elements (i.e from index 1 to 4) is 10, So the sequenceÂ
Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â generated is 10 10 10 15 15 90 90

Â

### Naive Approach:

The idea is very basic run a nested loop, the outer loop which will mark the starting point of the subarray of length K, the inner loop will run from the starting index to index+K, and print the maximum element among these K elements.Â

Follow the given steps to solve the problem:

• Create a nested loop, the outer loop from starting index to N – Kth elements. The inner loop will run for K iterations.
• Create a variable to store the maximum of K elements traversed by the inner loop.
• Find the maximum of K elements traversed by the inner loop.
• Print the maximum element in every iteration of the outer loop

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#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's code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `K = 3;``  ` `      ``// Function call``    ``printKMax(arr, N, K);``    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `// C program for the above approach``#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);``    ``}``}` `// Driver's Code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `K = 3;``  ` `      ``// Function call``    ``printKMax(arr, N, K);``    ``return` `0;``}`

## Java

 `// Java program for the above approach` `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's code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``, ``10` `};``        ``int` `K = ``3``;``      ` `          ``// Function call``        ``printKMax(arr, arr.length, K);``    ``}``}` `// This code is contributed by Sumit Ghosh`

## Python3

 `# Python3 program for the above approach` `# Method to find the maximum for each``# and every contiguous subarray``# 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's code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``9``, ``10``]``    ``N ``=` `len``(arr)``    ``K ``=` `3``    ` `    ``# Function call``    ``printMax(arr, N, K)` `# This code is contributed by Shiv Shankar`

## C#

 `// C# program for the above approach` `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's code``    ``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`

## Javascript

 `// JavaScript 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 size k.``function` `printKMax(arr,n,k) ``{ ``    ``let j, max; ` `    ``for` `(let i = 0; i <= n - k; i++) ``    ``{ ``        ``max = arr[i]; ` `        ``for` `(j = 1; j < k; j++) ``        ``{ ``            ``if` `(arr[i + j] > max) ``                ``max = arr[i + j]; ``        ``} ``         ``document.write( max + ``" "``); ``    ``} ``} ` `// Driver code` `    ``let arr = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]; ``    ``let n =arr.length; ``    ``let k = 3; ``    ``printKMax(arr, n, k); ` `// This code contributed by gauravrajput1 `

## PHP

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

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

```

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

## Maximum of all subarrays of size K using Max-Heap:Â

• Initialize an empty priority queue heap to store elements in decreasing order of their values, along with their indices.
• Push the first k elements of the input array arr into the priority queue heap along with their respective indices.
• The maximum element in the first window is obtained by accessing the top element of the priority queue heap. Push this maximum element into the answer vector ans.
• Process the remaining elements of arr starting from index k:
• Add the current element along with its index to the priority queue heap.
• Remove elements from the priority queue heap that are outside the current window. This is done by comparing the index of the top element in the heap with the index i – k. If the index of the top element is less than or equal to i – k, it means the element is outside the current window and should be removed.
• The maximum element in the current window is obtained by accessing the top element of the priority queue heap. Push this maximum element into the answer vector ans.
• Finally, return the answer vector ans containing the maximum elements in each sliding window.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to find the maximum element in each sliding``// window of size k``vector<``int``> maxSlidingWindow(vector<``int``>& arr, ``int` `k)``{``    ``vector<``int``> ans;``    ``priority_queue > heap;` `    ``// Initialize the heap with the first k elements``    ``for` `(``int` `i = 0; i < k; i++)``        ``heap.push({ arr[i], i });` `    ``// The maximum element in the first window``    ``ans.push_back(heap.top().first);` `    ``// Process the remaining elements``    ``for` `(``int` `i = k; i < arr.size(); i++) {` `        ``// Add the current element to the heap``        ``heap.push({ arr[i], i });` `        ``// Remove elements that are outside the current``        ``// window``        ``while` `(heap.top().second <= i - k)``            ``heap.pop();` `        ``// The maximum element in the current window``        ``ans.push_back(heap.top().first);``    ``}` `    ``return` `ans;``}` `int` `main()``{``    ``vector<``int``> arr = { 2, 3, 7, 9, 5, 1, 6, 4, 3 };``    ``int` `k = 3;` `    ``// Find the maximum element in each sliding window of``    ``// size k``    ``vector<``int``> result = maxSlidingWindow(arr, k);` `    ``// Print the results``    ``for` `(``auto` `i : result)``        ``cout << i << ``" "``;` `    ``return` `0;``}`

## Java

 `import` `java.util.ArrayList;``import` `java.util.List;``import` `java.util.PriorityQueue;` `public` `class` `Main {``    ``public` `static` `List maxSlidingWindow(``int``[] arr,``                                                 ``int` `k)``    ``{``        ``List ans = ``new` `ArrayList<>();``        ``PriorityQueue heap = ``new` `PriorityQueue<>(``            ``(a, b) -> b.value - a.value);` `        ``// Initialize the heap with the first k elements``        ``for` `(``int` `i = ``0``; i < k; i++) {``            ``heap.offer(``new` `Pair(arr[i], i));``        ``}` `        ``// The maximum element in the first window``        ``ans.add(heap.peek().value);` `        ``// Process the remaining elements``        ``for` `(``int` `i = k; i < arr.length; i++) {``            ``heap.offer(``new` `Pair(arr[i], i));` `            ``// Remove elements that are outside the current``            ``// window``            ``while` `(heap.peek().index <= i - k) {``                ``heap.poll();``            ``}` `            ``// The maximum element in the current window``            ``ans.add(heap.peek().value);``        ``}` `        ``return` `ans;``    ``}` `    ``static` `class` `Pair {``        ``int` `value;``        ``int` `index;` `        ``public` `Pair(``int` `value, ``int` `index)``        ``{``            ``this``.value = value;``            ``this``.index = index;``        ``}``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``2``, ``3``, ``7``, ``9``, ``5``, ``1``, ``6``, ``4``, ``3` `};``        ``int` `k = ``3``;` `        ``// Find the maximum element in each sliding window``        ``// of size k``        ``List result = maxSlidingWindow(arr, k);` `        ``// Print the results``        ``for` `(``int` `num : result) {``            ``System.out.print(num + ``" "``);``        ``}``    ``}``}`

## Python3

 `import` `heapq`  `def` `max_sliding_window(arr, k):``    ``ans ``=` `[]``    ``heap ``=` `[]` `    ``# Initialize the heap with the first k elements``    ``for` `i ``in` `range``(k):``        ``heapq.heappush(heap, (``-``arr[i], i))` `    ``# The maximum element in the first window``    ``ans.append(``-``heap[``0``][``0``])` `    ``# Process the remaining elements``    ``for` `i ``in` `range``(k, ``len``(arr)):``        ``heapq.heappush(heap, (``-``arr[i], i))` `        ``# Remove elements that are outside the current window``        ``while` `heap[``0``][``1``] <``=` `i ``-` `k:``            ``heapq.heappop(heap)` `        ``# The maximum element in the current window``        ``ans.append(``-``heap[``0``][``0``])` `    ``return` `ans`  `arr ``=` `[``2``, ``3``, ``7``, ``9``, ``5``, ``1``, ``6``, ``4``, ``3``]``k ``=` `3` `# Find the maximum element in each sliding window of size k``result ``=` `max_sliding_window(arr, k)` `# Print the results``for` `num ``in` `result:``    ``print``(num, end``=``" "``)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ``static` `List<``int``> MaxSlidingWindow(List<``int``> arr, ``int` `k)``    ``{``        ``List<``int``> ans = ``new` `List<``int``>();``        ``Queue<``int``> deque = ``new` `Queue<``int``>();` `        ``for` `(``int` `i = 0; i < arr.Count; i++)``        ``{``            ``// Remove elements that are outside the current window ``          ``// from the front of the deque``            ``while` `(deque.Count > 0 && deque.Peek() < i - k + 1)``                ``deque.Dequeue();` `            ``// Remove elements that are less than the current element ``          ``// from the back of the deque``            ``while` `(deque.Count > 0 && arr[deque.Peek()] < arr[i])``                ``deque.Dequeue();` `            ``// Add the current element's index to the back of the deque``            ``deque.Enqueue(i);` `            ``// If the current index is equal to or greater than k - 1, ``          ``// then we can start adding elements to the result list``            ``if` `(i >= k - 1)``                ``ans.Add(arr[deque.Peek()]);``        ``}` `        ``return` `ans;``    ``}` `    ``static` `void` `Main()``    ``{``        ``List<``int``> arr = ``new` `List<``int``> { 2, 3, 7, 9, 5, 1, 6, 4, 3 };``        ``int` `k = 3;` `        ``// Find the maximum element in each sliding window of size k``        ``List<``int``> result = MaxSlidingWindow(arr, k);` `        ``// Print the results``        ``foreach` `(``int` `i ``in` `result)``            ``Console.Write(i + ``" "``);` `        ``Console.ReadLine();``    ``}``}`

## Javascript

 `class Pair {``    ``constructor(value, index) {``        ``this``.value = value;``        ``this``.index = index;``    ``}``}` `function` `maxSlidingWindow(arr, k) {``    ``const ans = [];``    ``const heap = [];` `    ``// Initialize the heap with the first k elements``    ``for` `(let i = 0; i < k; i++) {``        ``heap.push(``new` `Pair(arr[i], i));``    ``}``    ``heap.sort((a, b) => b.value - a.value);` `    ``// The maximum element in the first window``    ``ans.push(heap[0].value);` `    ``// Process the remaining elements``    ``for` `(let i = k; i < arr.length; i++) {``        ``heap.push(``new` `Pair(arr[i], i));` `        ``// Remove elements that are outside the current window``        ``while` `(heap[0].index <= i - k) {``            ``heap.shift();``        ``}``        ``heap.sort((a, b) => b.value - a.value);` `        ``// The maximum element in the current window``        ``ans.push(heap[0].value);``    ``}` `    ``return` `ans;``}` `const arr = [2, 3, 7, 9, 5, 1, 6, 4, 3];``const k = 3;` `// Find the maximum element in each sliding window of size k``const result = maxSlidingWindow(arr, k);` `// Print the results``for` `(const num of result) {``    ``console.log(num + ``" "``);``}`

Output
```7 9 9 9 6 6 6

```

Time Complexity: O(NlogN), Where N is the size of the array.
Auxiliary Space: O(N), where N is the size of the array, this method requires O(N) space in the worst case when the input array is an increasing array

## Maximum of all subarrays of size K using Set:

To reduce the auxilary space to O(K), Set Data Structure can be used which allows deletion of any element in O(logn N) time. Thus the size of set will never exceed K, if we delete delete the (i-Kt)h element from the Set while traversing.

Follow the given steps to solve the problem:

1. Create a Set to store and find the maximum element.
2. Traverse through the array from start to end.
3. Insert the element in theSet.
4. If the loop counter is greater than or equal to k then delete the i-Kth element from the Set.
5. Print the maximum element of the Set.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to find the maximum element in each sliding``// window of size k``vector<``int``> maxSlidingWindow(vector<``int``>& arr, ``int` `k)``{``    ``vector<``int``> ans;``    ``set, greater>> st;` `    ``// Initialize the set with the first k elements``    ``for` `(``int` `i = 0; i < k; i++)``        ``st.insert({ arr[i], i });` `    ``// The maximum element in the first window``    ``ans.push_back((st.begin())->first);` `    ``// Process the remaining elements``    ``for` `(``int` `i = k; i < arr.size(); i++) {` `        ``// Add the current element to the set``        ``st.insert({ arr[i], i });` `        ``// Remove the (i-k)th element from the window``        ``st.erase({ arr[i - k], (i - k) });` `        ``// The maximum element in the current window``        ``ans.push_back(st.begin()->first);``    ``}` `    ``return` `ans;``}` `int` `main()``{``    ``vector<``int``> arr = { 2, 3, 7, 9, 5, 1, 6, 4, 3 };``    ``int` `k = 3;` `    ``// Find the maximum element in each sliding window of``    ``// size k``    ``vector<``int``> result = maxSlidingWindow(arr, k);` `    ``// Print the results``    ``for` `(``auto` `i : result)``        ``cout << i << ``" "``;` `    ``return` `0;``}`

## Java

 `import` `java.util.ArrayDeque;``import` `java.util.Deque;` `public` `class` `MaxSlidingWindow {``    ``// Function to find the maximum element in each sliding``    ``// window of size k``    ``static` `int``[] maxSlidingWindow(``int``[] arr, ``int` `k)``    ``{``        ``int` `n = arr.length;``        ``int``[] ans = ``new` `int``[n - k + ``1``];``        ``Deque maxInWindow = ``new` `ArrayDeque<>();` `        ``// Initialize maxInWindow with the first k elements``        ``for` `(``int` `i = ``0``; i < k; i++) {``            ``while` `(!maxInWindow.isEmpty()``                   ``&& arr[i]``                          ``>= arr[maxInWindow.peekLast()]) {``                ``maxInWindow.removeLast();``            ``}``            ``maxInWindow.addLast(i);``        ``}` `        ``// The maximum element in the first window``        ``ans[``0``] = arr[maxInWindow.peekFirst()];` `        ``// Process the remaining elements``        ``for` `(``int` `i = k; i < n; i++) {``            ``// Remove elements that are out of the current``            ``// window``            ``while` `(!maxInWindow.isEmpty()``                   ``&& maxInWindow.peekFirst() <= i - k) {``                ``maxInWindow.removeFirst();``            ``}` `            ``// Remove elements that are not needed in the``            ``// current window``            ``while` `(!maxInWindow.isEmpty()``                   ``&& arr[i]``                          ``>= arr[maxInWindow.peekLast()]) {``                ``maxInWindow.removeLast();``            ``}` `            ``maxInWindow.addLast(i);``            ``ans[i - k + ``1``] = arr[maxInWindow.peekFirst()];``        ``}` `        ``return` `ans;``    ``}` `    ``// Driver program``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``2``, ``3``, ``7``, ``9``, ``5``, ``1``, ``6``, ``4``, ``3` `};``        ``int` `k = ``3``;` `        ``// Find the maximum element in each sliding window``        ``// of size k``        ``int``[] result = maxSlidingWindow(arr, k);` `        ``// Print the results``        ``System.out.print(``            ``"Maximum elements in each sliding window: "``);``        ``for` `(``int` `i : result)``            ``System.out.print(i + ``" "``);``    ``}``}`

## Python

 `from` `collections ``import` `deque` `# Function to find the maximum element in each sliding window of size k`  `def` `maxSlidingWindow(arr, k):``    ``ans ``=` `[]``    ``deq ``=` `deque()` `    ``# Initialize the deque with the first k elements``    ``for` `i ``in` `range``(k):``        ``while` `deq ``and` `arr[i] >``=` `arr[deq[``-``1``]]:``            ``deq.pop()``        ``deq.append(i)` `    ``# The maximum element in the first window``    ``ans.append(arr[deq[``0``]])` `    ``# Process the remaining elements``    ``for` `i ``in` `range``(k, ``len``(arr)):``        ``# Remove elements that are out of the current window``        ``while` `deq ``and` `deq[``0``] <``=` `i ``-` `k:``            ``deq.popleft()` `        ``# Remove elements that are less than the current element``        ``while` `deq ``and` `arr[i] >``=` `arr[deq[``-``1``]]:``            ``deq.pop()` `        ``deq.append(i)` `        ``# The maximum element in the current window``        ``ans.append(arr[deq[``0``]])` `    ``return` `ans`  `# Main function``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``2``, ``3``, ``7``, ``9``, ``5``, ``1``, ``6``, ``4``, ``3``]``    ``k ``=` `3` `    ``# Find the maximum element in each sliding window of size k``    ``result ``=` `maxSlidingWindow(arr, k)` `    ``# Print the results``    ``print``(result)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program {``    ``// Function to find the maximum element in each sliding``    ``// window of size k``    ``static` `List<``int``> MaxSlidingWindow(List<``int``> arr, ``int` `k)``    ``{``        ``List<``int``> ans = ``new` `List<``int``>();``        ``List<``int``> maxInWindow = ``new` `List<``int``>();` `        ``// Initialize maxInWindow with the first k elements``        ``for` `(``int` `i = 0; i < k; i++) {``            ``while` `(``                ``maxInWindow.Count > 0``                ``&& arr[i]``                       ``>= arr[maxInWindow[maxInWindow.Count``                                          ``- 1]]) {``                ``maxInWindow.RemoveAt(maxInWindow.Count - 1);``            ``}``            ``maxInWindow.Add(i);``        ``}` `        ``// The maximum element in the first window``        ``ans.Add(arr[maxInWindow[0]]);` `        ``// Process the remaining elements``        ``for` `(``int` `i = k; i < arr.Count; i++) {``            ``// Remove elements that are out of the current``            ``// window``            ``while` `(maxInWindow.Count > 0``                   ``&& maxInWindow[0] <= i - k) {``                ``maxInWindow.RemoveAt(0);``            ``}` `            ``// Remove elements that are not needed in the``            ``// current window``            ``while` `(``                ``maxInWindow.Count > 0``                ``&& arr[i]``                       ``>= arr[maxInWindow[maxInWindow.Count``                                          ``- 1]]) {``                ``maxInWindow.RemoveAt(maxInWindow.Count - 1);``            ``}` `            ``maxInWindow.Add(i);``            ``ans.Add(arr[maxInWindow[0]]);``        ``}` `        ``return` `ans;``    ``}` `    ``static` `void` `Main(``string``[] args)``    ``{``        ``List<``int``> arr``            ``= ``new` `List<``int``>{ 2, 3, 7, 9, 5, 1, 6, 4, 3 };``        ``int` `k = 3;` `        ``List<``int``> result = MaxSlidingWindow(arr, k);` `        ``Console.WriteLine(``            ``"Maximum elements in each sliding window:"``);``        ``foreach``(``int` `i ``in` `result) { Console.Write(i + ``" "``); }``    ``}``}`

## Javascript

 `function` `maxSlidingWindow(arr, k) {``    ``const ans = [];``    ``const maxInWindow = [];` `    ``// Initialize maxInWindow with the first k elements``    ``for` `(let i = 0; i < k; i++) {``        ``while` `(maxInWindow.length > 0 && arr[i] >= arr[maxInWindow[maxInWindow.length - 1]]) {``            ``maxInWindow.pop();``        ``}``        ``maxInWindow.push(i);``    ``}` `    ``// The maximum element in the first window``    ``ans.push(arr[maxInWindow[0]]);` `    ``// Process the remaining elements``    ``for` `(let i = k; i < arr.length; i++) {``        ``// Remove elements that are out of the current window``        ``while` `(maxInWindow.length > 0 && maxInWindow[0] <= i - k) {``            ``maxInWindow.shift();``        ``}` `        ``// Remove elements that are not needed in the current window``        ``while` `(maxInWindow.length > 0 && arr[i] >= arr[maxInWindow[maxInWindow.length - 1]]) {``            ``maxInWindow.pop();``        ``}` `        ``maxInWindow.push(i);``        ``ans.push(arr[maxInWindow[0]]);``    ``}` `    ``return` `ans;``}` `const arr = [2, 3, 7, 9, 5, 1, 6, 4, 3];``const k = 3;` `const result = maxSlidingWindow(arr, k);` `console.log(``"Maximum elements in each sliding window: "` `+ result.join(``' '``));`

Output
```7 9 9 9 6 6 6

```

Time Complexity: O(NlogN), Where N is the size of the array.
Auxiliary Space: O(K), since size of set does not never exceeds K.

## Maximum of all subarrays of size K using Deque:Â

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 right side of it in current window. 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/back of Qi is the smallest of current window.

Below is the dry run of the above approach:Â

Follow the given steps to solve the problem:

• Create a deque to store K elements.
• Run a loop and insert the first K elements in the deque. Before inserting the element, check if the element at the back of the queue is smaller than the current element, if it is so remove the element from the back of the deque until all elements left in the deque are greater than the current element. Then insert the current element, at the back of the deque.
• Now, run a loop from K to the end of the array.
• Print the front element of the deque.
• Remove the element from the front of the queue if they are out of the current window.
• Insert the next element in the deque. Before inserting the element, check if the element at the back of the queue is smaller than the current element, if it is so remove the element from the back of the deque until all elements left in the deque are greater than the current element. Then insert the current element, at the back of the deque.
• Print the maximum element of the last window.

Below is the implementation of the above approach:

## C++

 `// CPP program for the above approach``#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()])` `            ``// Remove from rear``            ``Qi.pop_back();` `        ``// 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)` `            ``// Remove from front of queue``            ``Qi.pop_front();` `        ``// 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's code``int` `main()``{``    ``int` `arr[] = { 12, 1, 78, 90, 57, 89, 56 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `K = 3;` `    ``// Function call``    ``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()])` `                ``// Remove from rear``                ``Qi.removeLast();` `            ``// 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's code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``12``, ``1``, ``78``, ``90``, ``57``, ``89``, ``56` `};``        ``int` `K = ``3``;``      ` `          ``// Function call``        ``printMax(arr, arr.length, K);``    ``}``}``// This code is contributed by Sumit Ghosh`

## Python3

 `# Python3 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's code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``12``, ``1``, ``78``, ``90``, ``57``, ``89``, ``56``]``    ``K ``=` `3``    ` `    ``# Function call``    ``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[Qi.Count - 1]])` `                ``// Remove from rear``                ``Qi.RemoveAt(Qi.Count - 1);` `            ``// 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[0]] + ``" "``);` `            ``// Remove the elements which are``            ``// out of this window``            ``while` `((Qi.Count != 0) && Qi[0] <= 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[0]]);``    ``}` `    ``// Driver's code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = { 12, 1, 78, 90, 57, 89, 56 };``        ``int` `K = 3;``      ` `          ``// Function call``        ``printMax(arr, arr.Length, K);``    ``}``}` `// This code has been contributed by 29AjayKumar`

## Javascript

 `// We have used array in javascript to implement methods of dequeue``// A Dequeue (Double ended queue) based ``// method for printing maximum element of``// all subarrays of size k``function` `printKMax(arr,n,k)``{``    ``// creating string str to be printed at last``    ``let str =``""``;``    ` `    ``// 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 Qi(k);``    ``let Qi = [];` `    ``/* Process first k (or first window) ``     ``elements of array */``    ``let i;``    ``for` `(i = 0; i < k; ++i) ``    ``{``    ` `        ``// For every element, the previous``        ``// smaller elements are useless so``        ``// remove them from Qi``        ``while` `((Qi.length!=0) && arr[i] >= ``                            ``arr[Qi[Qi.length-1]])``          ` `             ``// Remove from rear``            ``Qi.pop();` `        ``// Add new element at rear of queue``        ``Qi.push(i);``    ``}` `    ``// Process rest of the elements, ``    ``// i.e., from arr[k] to arr[n-1]``    ``for` `(i; i < n; ++i) ``    ``{``    ` `        ``// The element at the front of ``        ``// the queue is the largest element of``        ``// previous window, so print it``        ``str+=arr[Qi[0]] + ``" "``;``        ``// console.log(arr[Qi[0]] + " ") ;` `        ``// Remove the elements which ``        ``// are out of this window``        ``while` `((Qi.length!=0) && Qi[0] <= i - k)``          ` `            ``// Remove from front of queue``            ``Qi.shift(); ` `        ``// Remove all elements ``        ``// smaller than the currently``        ``// being added element (remove ``        ``// useless elements)``        ``while` `((Qi.length!=0) && arr[i] >= arr[Qi[Qi.length-1]])``            ``Qi.pop();` `        ``// Add current element at the rear of Qi``        ``Qi.push(i);``    ``}` `    ``// Print the maximum element ``    ``// of last window``    ``str += arr[Qi[0]];``    ``console.log(str);``}` `let arr = [ 12, 1, 78, 90, 57, 89, 56 ];``let n = arr.length;``let k = 3;``printKMax(arr, n, k);` `// This code is contributed by akashish__`

Output
```78 90 90 90 89

```

Time Complexity: O(N).Â It seems more than O(N) at first look. It can be observed that every element of the array is added and removed at most once. So there are a total of 2n operations.
Auxiliary Space: O(K).Â Elements stored in the dequeue take O(K) space.

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

Previous
Next