【剑指Offer学习】【面试题65：滑动窗体的最大值】

最新推荐文章于 2024-12-23 15:35:36 发布

weixin_33817333

最新推荐文章于 2024-12-23 15:35:36 发布

阅读量95

点赞数

文章标签：面试数据结构与算法 java

题目：给定一个数组和滑动窗体的大小，请找出全部滑动窗体里的最大值。

举例说明

　　比如，假设输入数组{2,3,4,2,6,2,5,1}及滑动窗体的大小。那么一共存在6个滑动窗体，它们的最大值分别为{4,4,6,6,6,5}。

解题思路

　　假设採用蛮力法，这个问题似乎不难解决：能够扫描每个滑动窗体的全部数字并找出当中的最大值。假设滑动窗体的大小为k，须要O(k)时间才干找出滑动窗体里的最大值。对于长度为n的输入数组，这个算法总的时间复杂度是O(nk)。

　　实际上一个滑动窗体能够看成是一个队列。当窗体滑动时，处于窗体的第一个数字被删除，同一时候在窗体的末尾加入一个新的数字。

这符合队列的先进先出特性。

假设能从队列中找出它的最大数，这个问题也就攻克了。
　　在面试题21中。我们实现了一个能够用O(1)时间得到最小值的栈。相同，也能够用O(1)时间得到栈的最大值。同一时候在面试题7中，我们讨论了怎样用两个栈实现一个队列。

综合这两个问题的解决方法，我们发现假设把队列用两个栈实现，因为能够用O(1)时间得到栈中的最大值。那么也就能够用O(1)时间得到队列的最大值，因此总的时间复杂度也就降到了O(n)。
　　我们能够用这种方法来解决这个问题。

只是这样就相当于在一轮面试的时间内要做两个面试题，时间未必够用。再来看看有没有其他的方法。
　　以下换一种思路。我们并不把滑动窗体的每个数值都存入队列中，而仅仅把有可能成为滑动窗体最大值的数值存入到一个两端开口的队列。接着以输入数字{2,3,4,2,6,2,5,1}为例一步分析。
　　数组的第一个数字是2，把它存入队列中。第二个数字是3.因为它比前一个数字2大，因此2不可能成为滑动窗体中的最大值。

2先从队列里删除，再把3存入到队列中。此时队列中仅仅有一个数字3.针对第三个数字4的步骤相似，终于在队列中仅仅剩下一个数字4.此时滑动窗体中已经有3个数字。而它的最大值4位于队列的头部。
　　接下来处理第四个数字2。2比队列中的数字4小。当4滑出窗体之后2还是有可能成为滑动窗体的最大值，因此把2存入队列的尾部。

如今队列中有两个数字4和2，当中最大值4仍然位于队列的头部。

　　下一个数字是6.因为它比队列中已有的数字4和2都大，因此这时4和2已经不可能成为滑动窗体中的最大值。先把4和2从队列中删除。再把数字6存入队列。这个时候最大值6仍然位于队列的头部。
　　第六个数字是2.因为它比队列中已有的数字6小，所以2也存入队列的尾部。此时队列中有两个数字，当中最大值6位于队列的头部。
　　接下来的数字是5.在队列中已有的两个数字6和2里。2小于5。因此2不可能是一个滑动窗体的最大值，能够把它从队列的尾部删除。删除数字2之后，再把数字5存入队列。此时队列里剩下两个数字6和5，当中位于队列头部的是最大值6.
　　数组最后一个数字是1。把1存入队列的尾部。注意到位于队列头部的数字6是数组的第5个数字，此时的滑动窗体已经不包含这个数字了，因此应该把数字6从队列删除。那么怎么知道滑动窗体是否包含一个数字？应该在队列里存入数字在数组里的下标，而不是数值。当一个数字的下标与当前处理的数字的下标之差大于或者等于滑动窗体的大小时。这个数字已经从滑动窗体中滑出，能够从队列中删除了。

代码实现

import java.util.*;

public class Test65 {
    private static List<Integer> maxInWindows(List<Integer> data, int size) {
        List<Integer> windowMax = new LinkedList<>();

        // 条件检查
        if (data == null || size < 1 || data.size() < 1) {
            return windowMax;
        }

        Deque<Integer> idx = new LinkedList<>();

        // 窗体还没有被填满时。找最大值的索引
        for (int i = 0; i < size && i < data.size(); i++) {
            // 假设索引相应的值比之前存储的索引值相应的值大或者相等，就删除之前存储的值
            while (!idx.isEmpty() && data.get(i) >= data.get(idx.getLast())) {
                idx.removeLast();
            }

            //  加入索引
            idx.addLast(i);
        }

        // 窗体已经被填满了
        for (int i = size; i < data.size(); i++) {
            // 第一个窗体的最大值保存
            windowMax.add(data.get(idx.getFirst()));

            // 假设索引相应的值比之前存储的索引值相应的值大或者相等。就删除之前存储的值
            while (!idx.isEmpty() && data.get(i) >= data.get(idx.getLast())) {
                idx.removeLast();
            }

            // 删除已经滑出窗体的数据相应的下标
            if (!idx.isEmpty() && idx.getFirst() <= (i - size)) {
                idx.removeFirst();
            }

            // 可能的最大的下标索引入队
            idx.addLast(i);
        }

        // 最后一个窗体最大值入队
        windowMax.add(data.get(idx.getFirst()));

        return windowMax;

    }

    private static List<Integer> arrayToCollection(int[] array) {
        List<Integer> result = new LinkedList<>();
        if (array != null) {
            for (int i : array) {
                result.add(i);
            }
        }

        return result;
    }

    public static void main(String[] args) {

        // expected {7};
        List<Integer> data1 = arrayToCollection(new int[]{1, 3, -1, -3, 5, 3, 6, 7});
        System.out.println(data1 + "," + maxInWindows(data1, 10));

        // expected {3, 3, 5, 5, 6, 7};
        List<Integer> data2 = arrayToCollection(new int[]{1, 3, -1, -3, 5, 3, 6, 7});
        System.out.println(data2 + "," + maxInWindows(data2, 3));

        // expected {7, 9, 11, 13, 15};
        List<Integer> data3 = arrayToCollection(new int[]{1, 3, 5, 7, 9, 11, 13, 15});
        System.out.println(data3 + "," + maxInWindows(data3, 4));

        // expected  {16, 14, 12};
        List<Integer> data5 = arrayToCollection(new int[]{16, 14, 12, 10, 8, 6, 4});
        System.out.println(data5 + "," + maxInWindows(data5, 5));

        // expected  {10, 14, 12, 11};
        List<Integer> data6 = arrayToCollection(new int[]{10, 14, 12, 11});
        System.out.println(data6 + "," + maxInWindows(data6, 1));

        // expected  {14};
        List<Integer> data7 = arrayToCollection(new int[]{10, 14, 12, 11});
        System.out.println(data7 + "," + maxInWindows(data7, 4));
    }
}