Update structure of maximum or minimum value in the window - maximum value in the window

subject

Suppose a fixed size is W The window of , Cross in turn arr, Returns the maximum value of each slide out condition
for example ,arr= [4,3,5,4,3,3,6,7], W= 3. return ：[5,5,5,4,6,7].

Double ended queue meaning ： When the windows shrink in turn , The number of positions will become the maximum value in the window in turn

package com.harrison.class13;

import java.util.LinkedList;

/** * @author Harrison * @create 2022-03-25-13:07 * @motto  looking for him for thousand times in the crowd , Suddenly look back , The man was in the dim light . */
public class Code01_SlidingWindowMaxArray {
    
    public static int[] right(int[] arr, int w) {
    
        if (arr == null || arr.length < w || w < 1) {
    
            return null;
        }
        int N = arr.length;
        int[] res = new int[N - w + 1];
        int L = 0;
        int R = w - 1;
        int index = 0;
        while (R < N) {
    
            int max = arr[L];
            for (int i = L + 1; i <= R; i++) {
    
                max = Math.max(max, arr[i]);
            }
            res[index++] = max;
            L++;
            R++;
        }
        return res;
    }

    public static int[] getMaxWindow(int[] arr, int w) {
    
        if (arr == null || arr.length < w || w < 1) {
    
            return null;
        }
        int N = arr.length;
        int[] res = new int[N - w + 1];
        int index = 0;
        //  Drop the mark 
        LinkedList<Integer> qmax = new LinkedList<>();
        for (int R = 0; R < N; R++) {
    
            while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[R]) {
    
                qmax.pollLast();
            }
            qmax.addLast(R);
            // R-w： Window expiration subscript 
            if (qmax.peekFirst() == R - w) {
    
                qmax.pollFirst();
            }
            //  Whether a normal window is formed 
            if (R >= w - 1) {
    
                res[index++]=arr[qmax.peekFirst()];
            }
        }
        return res;
    }

    public static int[] generateRandomArray(int maxSize, int maxValue) {
    
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
    
            arr[i] = (int) (Math.random() * (maxValue + 1));
        }
        return arr;
    }

    // for test
    public static boolean isEqual(int[] arr1, int[] arr2) {
    
        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
    
            return false;
        }
        if (arr1 == null && arr2 == null) {
    
            return true;
        }
        if (arr1.length != arr2.length) {
    
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
    
            if (arr1[i] != arr2[i]) {
    
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
    
        int testTime = 100000;
        int maxSize = 100;
        int maxValue = 100;
        System.out.println("test begin");
        for (int i = 0; i < testTime; i++) {
    
            int[] arr = generateRandomArray(maxSize, maxValue);
            int w = (int) (Math.random() * (arr.length + 1));
            int[] ans1 = getMaxWindow(arr, w);
            int[] ans2 = right(arr, w);
            if (!isEqual(ans1, ans2)) {
    
                System.out.println("Oops!");
            }
        }
        System.out.println("test finish");
    }
}