Algorithm

Before discussing sliding window technique algorithm, let's assume if you need to traverse an array one element at a time, how will you do it?
Something like this: if array = {1,2,3,4,5} The traversal sequence will look like the highlighted element at each step:
step 1: {1,2,3,4,5}
step 2: {1,2,3,4,5}
step 3: {1,2,3,4,5}
step 4: {1,2,3,4,5}
step 5: {1,2,3,4,5}

But as the name suggests, in case of sliding window, instead of traversing the array 1 by 1, we would traverse a block of size K in the first step, and then simply shift the block ahead by one position at each step. You can visualise this as a sliding glass pane of a window frame. That's why it is called sliding window.For Example:
if array = {1,2,3,4,5}, and K = 2 The traversal sequence of sliding a window by size 2 would look like:
step 1: {1,2,3,4,5}
step 2: {1,2,3,4,5}
step 3: {1,2,3,4,5}
step 4: {1,2,3,4,5}

What is the benefit of using sliding window technique?
Before we discuss the benefit, can you spot the difference between the above two examples?
The difference is in the number of steps. In the first example of traditional traversal, there are 5 steps whereas in the second one, we just have 4 steps.

Although it doesn't make a lot of sense in the above example as the time complexity would be same, in a lot of problems, sliding window technique helps us avoid nested loops by replacing them with a single loop, dramatically reducing the time complexity.

Let us look at one relevant example: We are given an array of n integers where we need to find the maximum sum of k consecutive elements. The brute force approach for the given problem is to go to every index of the array and calculate the sum by running the inner nested loop k times for that index and then find the maximum sum consecutively. For the given array: Arr = {1,7,6,2,3,4,5} k = 2 Let us consider maxsum as INT_MIN.
The most basic approach that strikes in the first go is to use two nested loops. The outer loop is to traverse the array one by one, and the inner loop to calculate maximum of K consecutive elements at each step. 0th index:

Run the loop there 2 (k) times
So the currsum will be 8 and the maxsum will be updated as 8.

1st index:

After running loop here for 2 times, we will get currsum as 13
Since maxsum is smaller than currsum, we will update the maxsum as 13.

2nd index:

After running loop here for 2 times, we will get currsum