Sliding Window Maximum (Maximum of all Subarrays of size K)

Traditionally to find the maximum element in an array, we used a loop that iterates over all the elements and returns us the value. Pseudocode implementation is given below.

Pseudocode

// Finds the maximum element in the given array.
// arr: The array for which we want to find the maximum element.
// n: The size of the array.
int find_maximum_element(int arr[], int n)
{
    // Initialize the maximum element to the first element in the array.
    int max_element = arr[0];

    // Loop through the array and find the maximum element.
    for (int i = 1; i < n; i++)
    {
        if (arr[i] > max_element)
        {
            max_element = arr[i];
        }
    }

    // Return the maximum element.
    return max_element;
}

The sliding window maximum technique is a way to find the maximum element in each window of a given size in an array. This technique is useful in many applications, such as when processing streaming data, where you need to find the maximum element in a fixed-sized window of elements at each step.

To implement the sliding window maximum technique, you can use a nested loop approach, where the outer loop iterates over the windows in the array, and the inner loop finds the maximum element in each window. Alternatively, you can use a data structure such as a heap to keep track of the maximum element in each window, reducing the algorithm's time complexity.

In both cases, the sliding window maximum technique has a time complexity of O(n) or O(nlogk), depending on the implementation.

C Code

#include <stdio.h>
#include <stdlib.h>

// Finds the maximum element in the window of size k
// for the given array and k.
int find_sliding_window_maximum(int arr[], int n, int k)
{
    // Initialize the maximum element.
    int max_element = arr[0];

    // Loop through the array and find the maximum
    // element in each window of size k.
    for (int i = 0; i <= n - k; i++)
    {
        // Find the maximum element in the current window.
        for (int j = i; j < i + k; j++)
        {
            if (arr[j] > max_element)
            {
                max_element = arr[j];
            }
        }

        // Print the maximum element in the current window.
        printf("%d ", max_element);
    }

    // Return the maximum element.
    return max_element;
}

// Example usage of the find_sliding_window_maximum function.
int main()
{
    // The array for which we want to find the maximum element
    // in each window of size k.
    int arr[] = {1, 2, 3, 4, 5};

    // The size of the array.
    int n = sizeof(arr) / sizeof(arr[0]);

    // The size of the window.
    int k = 3;

    // Find and print the maximum element in each window of size k.
    int max_element = find_sliding_window_maximum(arr, n, k);
    printf("\n");

    // Print the maximum element in the whole array.
    printf("Maximum element in the array: %d\n", max_element);

    return 0;
}

Output

3 4 5 
Maximum element in the array: 5

Explanation

In this implementation, the find_sliding_window_maximum function takes in an array, arr, its size, n, and the size of the window, k. It then loops through the array and finds the maximum element in each window of size k. Finally, it prints the maximum element in each window and returns the maximum element in the whole array.

Note that this implementation has a time complexity of O(nk) because it uses nested loops to find the maximum element in each window. This can be improved by using a data structure such as a heap to keep track of the maximum element in each window, reducing the time complexity to O(nlogk).

C++ Code

// Here we have written the C++ programming language code to demonstrate the
// concept of sliding window maximum algorithm in C++
#include <iostream>
#include <deque>
using namespace std;

// Returns an array containing the maximum of all subarrays of size k
int* slidingWindowMax(int arr[], int n, int k) {
    // Initialize a deque that will store the indices of the array elements
    deque<int> dq;

    // Initialize an array to store the maximum of each subarray
    int* maxes = new int[n-k+1];

    // Process the first k elements of the array separately
    for (int i = 0; i < k; i++) {
        // Remove any element that is smaller than the current element
        // from the back of the deque
        while (!dq.empty() && arr[i] >= arr[dq.back()]) {
            dq.pop_back();
        }

        // Add the current element to the back of the deque
        dq.push_back(i);
    }

    // Process the remaining elements of the array
    for (int i = k; i < n; i++) {
        // The first element in the deque is the maximum of the previous
        // subarray, so store it in the maxes array
        maxes[i-k] = arr[dq.front()];

        // Remove any element that is smaller than the current element
        // from the back of the deque
        while (!dq.empty() && arr[i] >= arr[dq.back()]) {
            dq.pop_back();
        }

        // Remove any element that is outside the current window
        // from the front of the deque
        while (!dq.empty() && dq.front() <= i-k) {
            dq.pop_front();
        }

        // Add the current element to the back of the deque
        dq.push_back(i);
    }

    // Store the maximum of the last subarray
    maxes[n-k] = arr[dq.front()];

    return maxes;
}

// Test the function by printing the maximum of each subarray of size k
// Tha main driver code functionality starts from here
int main() {
    int arr[] = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;
    int n = sizeof(arr)/sizeof(arr[0]);

    int* maxes = slidingWindowMax(arr, n, k);
    for (int i = 0; i < n-k+1; i++) {
        cout << maxes[i] << " ";
    }
    cout << endl;

    return 0;
// The main driver code functionality ends from here
}

Output

3 3 5 6 7

Explanation:

This implementation uses a double-ended queue (deque) to store the indices of the array elements. The deque always maintains the following invariants:

The elements in the deque are in non-decreasing order, with the largest element at the front and the smallest element at the back.The elements in the deque are within the current window.

These invariants allow us to efficiently find the maximum of each subarray in linear time. The time complexity of this implementation is O(n).

Java Code

// Here we have written the Java programming language code to demonstrate 
// concept of sliding window maximum algorithm in Java 
import java.util.Deque;
import java.util.LinkedList;

public class SlidingWindowMaximum {

    // Returns an array containing the maximum of all subarrays of size k
    public static int[] slidingWindowMax(int[] arr, int k) {
        // Initialize a deque that will store the indices of the array elements
        Deque<Integer> dq = new LinkedList<>();

        // Initialize an array to store the maximum of each subarray
        int[] maxes = new int[arr.length-k+1];

        // Process the first k elements of the array separately
        for (int i = 0; i < k; i++) {
            // Remove any element that is smaller than the current element
            // from the back of the deque
            while (!dq.isEmpty() && arr[i] >= arr[dq.peekLast()]) {
                dq.removeLast();
            }

            // Add the current element to the back of the deque
            dq.addLast(i);
        }

        // Process the remaining elements of the array
        for (int i = k; i < arr.length; i++) {
            // The first element in the deque is the maximum of the previous
            // subarray, so store it in the maxes array
            maxes[i-k] = arr[dq.peekFirst()];

            // Remove any element that is smaller than the current element
            // from the back of the deque
            while (!dq.isEmpty() && arr[i] >= arr[dq.peekLast()]) {
                dq.removeLast();
            }

            // Remove any element that is outside the current window
            // from the front of the deque
            while (!dq.isEmpty() && dq.peekFirst() <= i-k) {
                dq.removeFirst();
            }

            // Add the current element to the back of the deque
            dq.addLast(i);
        }

        // Store the maximum of the last subarray
        maxes[arr.length-k] = arr[dq.peekFirst()];

        return maxes;
    }

    // Test the function by printing the maximum of each subarray of size k
    // The main driver code functionality starts from here
    public static void main(String[] args) {
        int[] arr = {1, 3, -1, -3, 5, 3, 6, 7};
        int k = 3;

        int[] maxes = slidingWindowMax(arr, k);
        for (int i = 0; i < arr.length-k+1; i++) {
            System.out.print(maxes[i] + " ");
        }
        System.out.println();
    
        // The main driver code functionality ends from here
    }
}

Output

3 3 5 5 6 7

The pseudocode in Java (using stack approach)

// Window size
int k = 3;

// Input array
int[] arr = new int[] {1, 2, 3, 1, 4, 5, 2, 3, 6};

// Stack for storing the current window
Stack<Integer> stack = new Stack<>();

// Sliding window maximum
for (int i = 0; i < arr.length; i++) {
  // Remove elements from the stack that are no longer in the current window
  while (!stack.isEmpty() && stack.peek() < i - k + 1) {
    stack.pop();
  }

  // Remove elements from the stack that are smaller than the current element
  while (!stack.isEmpty() && arr[stack.peek()] < arr[i]) {
    stack.pop();
  }

  // Add the current element to the stack
  stack.push(i);

  // If the current window is complete, print the maximum value
  if (i >= k - 1) {
    System.out.println(arr[stack.peek()]);
  }
}

Python code

# Here we are writing down the Python programming language code to demonstrate the concept of Sliding Window Maximum (Maximum of all Subarrays of size K)

# main driver code starts from here in Python 
# Window size
k = 3

# Input array (known as list in Python)
arr = [1, 2, 3, 1, 4, 5, 2, 3, 6]

# Sliding window maximum
for i in range(len(arr) - k + 1):
  print(max(arr[i:i+k]))
  
# end of sliding window technique in Python

Output

C# Code

//  Here we are writing down the C# code to demonstrate the concept of 
//  Sliding Window Maximum (Maximum of all Subarrays of size K) in C#
using System;

public class HelloWorld
{
    
    // The main driver code functionality starts from here
    public static void Main(string[] args)
    {
        
        
        // Window size
int k = 3;

// Input array
int[] arr = new int[] {1, 2, 3, 1, 4, 5, 2, 3, 6};

// Sliding window maximum
for (int i = 0; i < arr.Length - k + 1; i++)
{
  // Get the maximum value in the current window
  int max = arr[i];
  for (int j = i + 1; j < i + k; j++)
  {
    max = Math.Max(max, arr[j]);
  }

  // Print the maximum value
  Console.WriteLine(max);
}

        
        
    }
// The main driver code functionality ends from here    
}

Output

JavaScript Code

//  Here we are writing down the JS code to demonstrate the concept of 
//  Sliding Window Maximum (Maximum of all Subarrays of size K) in JavaScript

// Window size
const k = 3;

// Input array
const arr = [1, 2, 3, 1, 4, 5, 2, 3, 6];

// Sliding window maximum
for (let i = 0; i < arr.length - k + 1; i++) {
  // Get the maximum value in the current window
  let max = arr[i];
  for (let j = i + 1; j < i + k; j++) {
    max = Math.max(max, arr[j]);
  }

  // Print the maximum value
  console.log(max);
}

// main driver code functionality ends from here

Output

Why is the Sliding Window Technique better than other Methods for finding the Maximum Element?

The sliding window maximum technique is a useful algorithm for finding the maximum element in each window of a given size in an array. It is often used in applications where you must process streaming data and find the maximum element in a fixed-sized window at each step.

One reason why the sliding window maximum technique may be better than other methods for finding the maximum element is that it can be implemented using a simple nested loop approach, which has a time complexity of O(nk), where n is the size of the array and k is the size of the window. This is relatively efficient compared to other methods, such as sorting the array and finding the maximum element, which has a time complexity of O(nlogn).

Another reason why the sliding window maximum technique may be better is that it can be easily modified to use a data structure such as a heap to keep track of the maximum element in each window, which can reduce the time complexity to O(nlogk). This can be more efficient than other methods for finding the maximum element in a large array, especially if the size of the window is much smaller than the size of the array.

Overall, the sliding window maximum technique is a useful and efficient algorithm for finding the maximum element in each window of a given size in an array.

Next TopicAVL Trees Operations

← prev next →