剑指offer 滑动窗口问题

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[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]}。

本人思路：

每次滑动，总是减去一个值，新增一个值；如果新增值大于上一个窗口的最大值，那么新增值为本窗口的最大值；否则，如果上一个窗口最大值大于移除的那个元素，则上一个窗口的最大值为本窗口最大值； 如果移除元素为上一个窗口最大值，则将本窗口所有元素统计最大值。

public class Window  {
    public static void main(String args[]){
        int A[] = new int[]{10,9,8,7,6,5,4,3,2,1};
        int size = 3;
//        int result[] = getMaxinWindow(A, size);
//        Print.printArray(result);

        Window win = new Window() ;
        ArrayList<Integer> ers = win.maxInWindows(A,size);
        Print.printArray(ers);
    }

    /**
     * 获得每个滑动窗口最大值
     * @param params ： 已知数组
     * @param size ： 滑动窗口大小
     * @return
     */
    public static int[] getMaxinWindow(int[] params, int size){
        // 参数检查
        if(params == null|| params.length < 1 || size < 1 || size > params.length){
            return null ;
        }
        // 最大值个数为 params.length + 1- size
        int[] result = new int[params.length - size + 1] ;
        // 第一个滑动窗口最大值
        for(int i= 0 ; i< size ; i ++){
            if(result[0] < params[i]){
                result[0] = params[i];

            }
        }
        for (int i = size; i < params.length; i++) {
            if (params[i] >= result[i - size]) { /// 当前值大于等于前面窗口所有值则当前值为新窗口最大值
                result[i - size + 1] = params[i];
            } else if (result[i - size] > params[i - size]) { // 当前值小于最大值，且最大值没有被移除，新窗口最大值为上一个窗口最大值
                result[i - size + 1] = result[i - size];
            } else{ // 重新计算当前窗口最大值
                int temp  = getMax(params, i -size + 1, i) ;
                if(temp == Integer.MIN_VALUE){
                   return null ;
               }
                result[i - size + 1] = temp;
            }
        }
        return result ;
    }

    private static int getMax(int[] params, int i, int i1) {
        if(params == null || i < 0 || i1 < i || i1 > params.length){
            return Integer.MIN_VALUE ;
        }
        int max = params[i] ;
        for(int temp = i ; temp <= i1 ; temp ++){
            if(max < params[temp]){
                max = params[temp];
            }
        }
        return  max ;
    }
}

经过运行，本算法可以正常得出结果。算法的时间复杂度为介于O（n）和O(n*k)之间, n为数组中元素个数，k为窗口大小。

如果数组为降序排列，时间复杂度为O(n * k) 。

在网上搜索，发现了另外一种解法见 链接 http://blog.csdn.net/sbq63683210/article/details/51707589

这种解法采用了双端队列的数据结构，每次得到的窗口最大值的索引都放在队列的头部；并且队列保持的索引，在数组中为非降序排列。每次队列头部保存的索引要么移除，要么保留。然后根据非降序规则添加新的索引进来。这样有效排除了，窗口中小于当前值的元素。这种算法的时间复杂度为O（n）。