Sliding Window Algorithm en JavaScript: Aprende con Ejemplos 2025

Sliding Window Explicado

Muchos problemas en entrevistas técnicas requieren encontrar una subsecuencia continua dentro de un array o string, como por ejemplo:

• La suma más alta de una subarray de tamaño fijo.
• La subcadena más larga sin caracteres repetidos.
• El número de anagramas dentro de una cadena de texto.

Una solución común (pero poco eficiente) sería usar dos bucles anidados para revisar todas las combinaciones posibles. Esto suele tener una complejidad O(n²), lo que no escala bien cuando el tamaño de los datos crece.

Ahí es donde entra sliding window: una técnica que permite resolver este tipo de problemas de forma más eficiente, generalmente en O(n).

Nota: Si no estás familiarizado con la notación O(n), no te preocupes, te recomiendo leer el artículo de Big O Notation para entender cómo funciona.

La idea es mantener una "ventana" que cubre una parte del array o string, y mover esa ventana de forma progresiva sin recalcular todo desde cero cada vez. De ahí su nombre: sliding (deslizante) window (ventana). Esta ventana puede ser de tamaño fijo o dinámico, dependiendo del problema.

Por esta razón, es una de las técnicas utilizadas en entrevistas de empresas como Amazon, Meta o Google, especialmente en problemas con arrays o strings.

Vamos a ver unos ejemplos prácticos para entender cómo funciona.

Ejemplo del Algoritmo Sliding Window

El algoritmo sliding window o ventana deslizante se basa en mantener una ventana móvil que se ajusta a medida que recorres un array o string. Dependiendo del problema, la ventana puede ser de tamaño fijo o variable.

Veamos un ejemplo sencillo para entender cómo funciona.

Queremos encontrar la suma máxima de cualquier subarray de tamaño k = 3 en el siguiente array:

const array = [2, 3, 5, 1, 6]
const k = 3

Representamos la cantidad de elementos que queremos sumar como k. En este caso, k es igual a 3, lo que significa que queremos sumar 3 elementos consecutivos del array.

Paso 1: Inicializamos la primera ventana y valores

Ventana inicial: [2, 3, 5].

También vamos a necesitar las siguientes variables:

• maxSum: para almacenar la suma máxima de todas las ventanas.
• windowSum: para almacenar la suma de la ventana en curso ya que la ventana se moverá.

Ahora vamos a calcular la suma de esta ventana.

La suma de los elementos es 2 + 3 + 5 = 10.

En resumen: la ventana inicial es [2, 3, 5], y la suma de esa ventana es de 10.

En código, esto se vería así:

const array = [2, 3, 5, 1, 6]

let maxSum = 0
let windowSum = 0

// obtenemos los valores directamente
windowSum = array[0] + array[1] + array[2]
maxSum = windowSum // inicializamos maxSum con la suma de la primera ventana

Nota: esto se puede hacer de forma sencilla usando un bucle for, pero en este caso lo haremos de forma manual para entender el concepto.

En este punto, sólo hemos calculado la suma de la primera ventana en curso.

Ahora, necesitamos mover la ventana una posición a la derecha y calcular la nueva suma.

Paso 2: Movemos la ventana una posición a la derecha

Ahora vamos a calcular la nueva suma de la ventana, usando la suma anterior en windowSum.

Si en la primera ventana sumamos los índices 0, 1 y 2, ahora sumamos los índices 1, 2 y 3, y después restamos el índice que salió de la ventana (índice 0) para no recalcular todo desde cero.

• Valor de maxSum de la ventana anterior: 10
• Valor de windowSum de la ventana anterior: 10
• Nueva ventana: [3, 5, 1]
• Suma del nuevo elemento de la ventana y windowSum: windowSum + array[3] que es igual a: 10 + 1 = 11
• Restamos el índice que salió de la ventana anterior (array[0]): windowSum - array[0] que es igual a: 11 - 2 = 9
• Valor de maxSum se mantiene en 10 porque 10 > 9.

windowSum += array[3] - array[0] // sumamos el nuevo elemento y restamos el que salió

// recuerda que maxSum es igual a 10 por la primera ventana
// asignamos el valor que sea mayor entre maxSum y windowSum
maxSum = Math.max(maxSum, windowSum)

Es importante recalcar que no volvemos a sumar todos los elementos de la nueva ventana. En su lugar, restamos el elemento que salió de la ventana anterior (array[0]) y sumamos el nuevo elemento que entra en la ventana (array[3]).

Esto nos da la nueva suma de la ventana sin recalcular todo desde cero y es el corazón del algoritmo sliding window en este ejemplo.

Paso 3: Movemos la ventana otra vez

Nueva ventana: [5, 1, 6].

Repetimos de nuevo el proceso:

• Valor de maxSum de la ventana anterior: 10
• Valor de windowSum de la ventana anterior: 9
• Nueva ventana: [5, 1, 6]
• Suma del nuevo elemento de la ventana y windowSum: windowSum + array[4] que es igual a: 9 + 6 = 15
• Restamos el índice que salió de la ventana anterior (array[1]): windowSum - array[1] que es igual a: 15 - 3 = 12
• Valor de maxSum se actualiza a 12 porque 12 > 10.

windowSum += array[4] - array[1]

maxSum = Math.max(maxSum, windowSum)

Debido a que ya hemos recorrido todo el array, no podemos mover la ventana más. Así que termina nuestro algoritmo.

Resultado Final

El subarray de tamaño 3 con suma máxima es [5, 1, 6] con una suma de 12 🥳

Como puedes ver, una vez que logras entender el concepto de sliding window, forma parte de tu caja de herramientas como desarrollador y se vuelve más de entender.

Ejemplo de Ventana Deslizante con Código JavaScript

Ahora que hemos visto el concepto, veamos cómo se implementa en código JavaScript.

Enunciado del problema:

Encuentra la suma máxima de cualquier subarray de tamaño k en un array de números enteros positivos dado.

// Recibimos un array y un número k que será el tamaño de la ventana
function maxSumSubarray(array, k) {
  // Esto funcionará sólo si los números son enteros positivos
  // Si puedes tener números negativos, entonces puedes usar:
  // let maxSum = -Infinity
  // para garantizar que siempre se actualice el valor al inicio
  let maxSum = 0
  let windowSum = 0

  // Inicializamos la ventana iterando sobre los primeros k elementos
  for (let i = 0; i < k; i++) {
    windowSum += array[i]
  }
  maxSum = windowSum

  // Movemos la ventana con otro ciclo,
  // empezando desde el índice k hasta el final del array
  for (let i = k; i < array.length; i++) {
    const currentValue = array[i]
    const previousValue = array[i - k]
    // Actualizamos la suma de la ventana
    windowSum += currentValue - previousValue
    // Asignamos cualquiera de los dos valores que sea mayor
    maxSum = Math.max(maxSum, windowSum)
  }

  return maxSum
}

const array = [2, 3, 5, 1, 6]
const k = 3

console.log(maxSumSubarray(array, k)) // 12

Como puedes ver, es la misma lógica que explicamos antes, pero ahora en código JavaScript.

Algunos puntos importantes a tener en cuenta:

• La complejidad de tiempo es O(n) donde n son los elementos del array.
  • Esto es así porque recorremos el array dos veces: una para inicializar la ventana y otra para moverla, donde O(2n) se simplifica a O(n).
• La complejidad de espacio es O(1) porque no usamos estructuras adicionales que dependan del tamaño del input.
  • Solo usamos variables para almacenar la suma y el índice.
• La solución es eficiente y escalable, lo que la hace ideal para problemas de entrevistas.
• Considera casos donde k es mayor que el tamaño del array o donde el array está vacío.
  • Puedes lanzar un error o devolver null según lo que necesites.
• Recuerda que la solución puede variar dependiendo de los requisitos del problema.
  • Por ejemplo, si el array puede contener números negativos, la lógica de la ventana deslizante se mantendría, pero la forma de calcular la suma podría cambiar.

Por eso, cuando aprendes un algoritmo, lo más importante es comprender el concepto detrás de él en vez de memorizar el código, porque en las entrevistas existen muchas variantes de un mismo problema y es imposible que memorices cada una de ellas.

Cuándo Usar Sliding Window

Usa sliding window cuando:

• Estás trabajando con arrays o strings secuenciales.
• El problema requiere analizar subsecuencias contiguas (ej: "encuentra la suma más alta de una ventana de tamaño k").
• El enunciado sugiere "explorar un rango de valores dentro de una lista o colección de elementos" pero quieres una solución más eficiente.
• Puedes optimizar evitando recomputar toda la ventana desde cero cada vez.

Ejemplos típicos en entrevistas:

• Máxima suma de subarray de tamaño k (el ejemplo que vimos).
• Substring más largo sin caracteres repetidos.
• Contar anagramas dentro de un string.
• Encontrar la longitud mínima de una subcadena con cierta suma.

Practica el Ejercicio de este Artículo en CodeSandbox

He creado un entorno en CodeSandbox para que puedas practicar el ejercicio del artículo. Puedes ver el código y hacer tus propias pruebas.

Sólo necesitas crear una cuenta gratuita en CodeSandbox y podrás editar el código directamente.

Aquí tienes el enlace: Ver el ejercicio en CodeSandbox

Sliding Window: Problemas de Entrevista

Si quieres practicar más problemas de entrevistas usando sliding window, aquí tienes una lista de problemas comunes que puedes resolver:

1. Longest Substring Without Repeating Characters

Dado un string, encuentra la longitud de la subcadena más larga que no contiene caracteres repetidos. Sliding window se usa para mantener una ventana válida sin repeticiones.

2. Maximum Sum Subarray of Size K

Encuentra la suma máxima posible de cualquier subarray contiguo de tamaño k. Es el clásico caso introductorio para sliding window fijo.

3. Minimum Size Subarray Sum

Dado un array y un valor target, encuentra la longitud mínima de un subarray cuya suma sea al menos igual a target. Aquí se usa sliding window variable para ajustar dinámicamente la ventana.

4. Permutation in String

Dado un string s1, determina si alguna permutación de s1 existe en otro string s2. Sliding window ayuda a comparar ventanas del mismo tamaño con la frecuencia de caracteres.

5. Longest Repeating Character Replacement

Encuentra la longitud máxima de una subcadena que puedas hacer con el mismo carácter, permitiendo reemplazar hasta k caracteres. Sliding window se usa para mantener una ventana válida que cumpla esa condición.

6. Find All Anagrams in a String

Encuentra todos los índices donde un string p es un anagrama dentro de otro string s. Sliding window permite mantener la frecuencia de letras y compararlas en cada paso.

7. Longest Substring with At Most K Distinct Characters

Dado un string, encuentra la subcadena más larga que contenga como máximo k caracteres distintos. Sliding window con un mapa de frecuencias ayuda a mantener el control.

8. Longest Substring with At Most Two Distinct Characters

Versión especializada del anterior, útil como paso intermedio para problemas más complejos. También se resuelve con sliding window variable.

9. Count of Anagrams

Cuenta cuántas veces aparece cualquier anagrama de un patrón dentro de un string más largo. Requiere mantener conteo de caracteres mientras se desliza la ventana.

10. Longest Substring with At Most K Distinct Characters

Sí, este problema se repite en entrevistas porque puede tener variaciones en la implementación o restricciones adicionales. Asegúrate de entenderlo bien.

Más Recursos Para Pasar Entrevistas y Aprender

Recursos de Developero:

• Si no estás recibiendo llamadas de entrevistas, revisa el artículo Cómo hacer un curriculum de programador para que te CONTRATEN
• Si no estás pasando entrevistas técnicas, revisa el artículo Code Interview Preparation: Cómo Responder una Entrevista Técnica Exitosamente
• Si te cuesta trabajo entender Big O notation, revisa el artículo Ejemplos de notación Big O en JavaScript
• Ahora si también quieres prepararte para entrevistas de diseño de sistemas, entonces revisa el artículo Mega guía completa de aprendizaje y preparación para entrevistas de diseño de sistemas

Con estos contenidos, estás más cerca de convertirte en ese perfil técnico que todas las empresas quieren.

Otros recursos:

• Repositorio de Github Data Structures and Algorithms
• Repositorio de Github Coding Interview University

Sobre el autor

Soy Juan Correa, un desarrollador con experiencia construyendo productos reales y enseñando a otros profesionales.

Escribo contenido práctico para ayudarte a pasar entrevistas técnicas, mejorar como dev y tomar mejores decisiones en tu código.

Conecta conmigo en LinkedIn o YouTube si buscas un consejo, quieres seguir aprendiendo sobre desarrollo web, entrevistas técnicas y más.