Dado un arreglo y un tamaño de ventana deslizante, el objetivo es encontrar los valores máximos en cada ventana a medida que esta se desplaza a lo largo del arreglo. Por ejemplo, para el arreglo {2,3,4,2,6,2,5,1} con un tamaño de ventana 3, existen 6 vetnanas deslizantes, y sus máximos respectivos son {4,4,6,6,6,5}. Las ventanas deslizantes para este arreglo son: {[2,3,4],2,6,2,5,1}, {2,[3,4,2],6,2,5,1}, {2,3,[4,2,6],2,5,1}, {2,3,4,[2,6,2],5,1}, {2,3,4,2,[6,2,5],1}, {2,3,4,2,6,[2,5,1]}. Cuando el tamaño de la ventana excede la longitud del arreglo, se debe retornar un resultado vacío.

Ejemplo: Entrada: [2,3,4,2,6,2,5,1],3Salida: [4,4,6,6,6,5]

Enfoque Básico con Doble Índice

Este método utiliza dos índices para definir los límites de cada ventana y calcula el máximo mediante una búsqueda lineal dentro de cada ventana.

class Solucion {
    public int[] maximosVentana(int[] datos, int tamVentana) {
        if (tamVentana > datos.length) {
            return new int[0];
        }
        int[] resultado = new int[datos.length - tamVentana + 1];
        int maxValor = Integer.MIN_VALUE;
        int inicio = 0;
        int fin = inicio + tamVentana - 1;
        
        while (fin < datos.length) {
            for (int idx = inicio; idx <= fin; idx++) {
                if (datos[idx] > maxValor) {
                    maxValor = datos[idx];
                }
            }
            resultado[inicio] = maxValor;
            maxValor = Integer.MIN_VALUE;
            inicio++;
            fin++;
        }
        return resultado;
    }
}

La complejidad temporal de esta solución es O(n*k), donde n es la longitud del arreglo y k el tamaño de la vantana, debido a que recalcula el máximo desde cero para cada ventana.

Enfoque Optimizado con Estructura de Datos

Una implementación más eficiente utiliza una cola doblemente terminada (deque) para mantener índices de elementos potencialmente máximos, reduciendo operaciones redundantes.

import java.util.*;

class Solucion {
    public int[] maximosVentana(int[] numeros, int k) {
        if (numeros == null || numeros.length == 0) {
            return new int[0];
        }
        int[] salida = new int[numeros.length - k + 1];
        Deque<Integer> indices = new ArrayDeque<>();
        
        for (int i = 0, j = 0; i < numeros.length; i++) {
            if (!indices.isEmpty() && i - indices.peekFirst() >= k) {
                indices.pollFirst();
            }
            while (!indices.isEmpty() && numeros[i] > numeros[indices.peekLast()]) {
                indices.pollLast();
            }
            indices.offerLast(i);
            if (i >= k - 1) {
                salida[j++] = numeros[indices.peekFirst()];
            }
        }
        return salida;
    }
}