See More

- [1 单调栈和窗口及其更新结构](#1) * [1.1 窗口](#11) + [1.1.1 滑动窗口是什么？](#111) + [1.1.2 滑动窗口能做什么？](#112) + [1.1.3 维护窗口滑动的更新结构](#113) + [1.1.4 高频题：求滑动窗口最大值](#114) + [1.1.5 高频题二：达标子数组数量问题](#115) + [1.1.6 如何优化一个问题？](#116) * [1.2 单调栈](#12) + [1.2.1 单调栈结构](#121) + [1.2.2 单调栈的应用](#122)

1 单调栈和窗口及其更新结构

1.1 窗口

1.1.1 滑动窗口是什么？

> 窗口只是我们脑海中的一个范围，用过L和R来规定我们窗口的边界。保证L<=R这个条件 1、滑动窗口是一种想象出来的数据结构； 2、滑动窗口有左边界L和右边界R 3、在数组或者字符串或者一个序列上，记为S,窗口就是S[L...R]这一部分 4、L往右滑动意味着一个样本出了窗口，R往右滑意味着一个样本进了窗口 5、 L和R都只能往右滑动

1.1.2 滑动窗口能做什么？

滑动窗口、首尾指针等技巧，说白了就是一种求解问题的流程设计。

1.1.3 维护窗口滑动的更新结构

> 例如我们求窗口内最大值问题 > 用单调双端队列来实现，双端队列就是我们的双向链表结构。我们保证我们的双端队列从头部到尾部数值是**从大到小**的 1、 如果窗口的R位置往右移动，我们把进入窗口的这个数从尾部加入到双端队列。如果当前数比该数的前一个数大（从尾部看）那么队列中小于等于的数弹出。直到小于队列的前一个数，加入该数。 2、如果窗口的L位置往右移动，预示着有数要出我们的窗口，我们从双端队列的头部观看要出去的数是不是我们头部队列的数。是就弹出头部的数，不是就不做任何操作 3、我们窗口结构一直被维护，双端队列右边进，左边出。那么窗口的最大值就是我们双端队列最左侧（头部）的值 ==双端队列结构实质上指的是：如果此时形成的窗口状况，不想让R往右动了，而让L往右动。谁会以此成为最大值的优先级。为什么弹出的数不再找回，原因是在窗口滑动的过程中，被弹出的数的优先级已经被后来的大数取代了，这就是尾端加入，前一个数比当前数小则弹出，比当前数大就加入当前数的道理== > 反之，如果我们要窗口内最小值，只需要维护我们的双端队列单调递增的，既由小到大的即可 复杂度：窗口滑动经过的数，最多进双端队列一次，最多出双端队列一次，如果窗口滑动了N个数，时间复杂度就是O(N)，单次平均O(1)。

1.1.4 高频题：求滑动窗口最大值

假设一个固定大小为W的窗口，以此划过arr，返回每一次划出状况的最大值 例如，`arr=[4, 3, 5, 4, 3, 3, 6, 7]` 返回：`[5, 5, 5, 4, 6, 7]` 分析：窗口起始是4,3,5,窗口内最大值是5。窗口向右滑动变为3,5,4最大值5...... ```Java package class01; import java.util.LinkedList; public class Code01_SlidingWindowMaxArray { public static int[] getMaxWindow(int[] arr, int w) { if (arr == null || w < 1 || arr.length < w) { return null; } // Java中LinkedList就是双端队列，双向链表 // 其中放的是下标位置，头代表 （大->小）尾 LinkedList qmax = new LinkedList(); // 窗口在滑动的过程中，最终会生成arr长度-窗口起始宽度+1个值 int[] res = new int[arr.length - w + 1]; int index = 0; // L...R // R for (int R = 0; R < arr.length; R++) { // 当前让 i -> [i] 进窗口 ， i 就是 r // R 位置的值 可以放在比他大的数后，或者空 // 双端队列不为空，且双端队列尾部的值小于当前要进入窗口的值 while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[R]) { // 双端队列从尾部弹出 qmax.pollLast(); } // 经过上述的while，最终把当前进入窗口的数放入双端队列的尾部 qmax.addLast(R); // 数进来了 // 如果窗口没有形成W的长度之前，不弹出数字的 // 当前下标是R, R-W就是需要过期的下标。 // 如果双端队列的头部保存的下标等于R-W，就头部弹出。实质R-W就是我们原始结构的L下标 if (qmax.peekFirst() == R - w) { qmax.pollFirst(); } // 以上窗口更新做完了 // 窗口没有形成W长度之前，不收集答案。形成W长度后，每一次收集一个答案 if (R >= w - 1) { res[index++] = arr[qmax.peekFirst()]; } } return res; } // for test public static int[] rightWay(int[] arr, int w) { if (arr == null || w < 1 || arr.length < w) { return null; } int[] res = new int[arr.length - w + 1]; int index = 0; int L = 0; int R = w - 1; while (R < arr.length) { 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; } // for test 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 = rightWay(arr, w); if (!isEqual(ans1, ans2)) { System.out.println("Oops!"); } } System.out.println("test finish"); } } ```

1.1.5 高频题二：达标子数组数量问题

给定一个整形数组arr，和衣蛾整数num。某个arr中的子数组sub，如果想达标，必须满足:sub中最大值-sub中最小值<=num，返回arr中达标子数组的数量 > 子数组是连续的 > 结论1：对于[L...R]范围达标，那么[L...R]上的子数组都达标。max[L...R]肯定比其子数组的max要大，min[L...R]肯定比其范围内的子数组要小，那么[L...R]上满足max - min < num，则其子数组必定满足 > 同理可得结论2：对于[L...R]范围不达标，那么扩展范围后的[L'...R']也不达标 > 我们建立两个双端队列，一个是窗口最大值的双端队列，一个是窗口最小值的双端队列。我们扩展我们的窗口R加1，每扩展一个判断是否仍然达标，达标继续扩展，不达标就停，可以得到本次子数组的达标情况，接着缩小我们的窗口L加1，继续...。窗口滑动不会回退，整体O(N) ```Java package class01; import java.util.LinkedList; public class Code02_AllLessNumSubArray { public static int getNum(int[] arr, int num) { if (arr == null || arr.length == 0) { return 0; } // 窗口内最小值的更新结构 LinkedList qmin = new LinkedList(); // 窗口内的最大值的更新结构 LinkedList qmax = new LinkedList(); int L = 0; int R = 0; // [L..R) -> [0,0) 窗口内无数 [1,1) // [0,1) -> [0~0] 窗口里只有一个数 int res = 0; // L是开头位置，尝试每一个开头 while (L < arr.length) { // 如果此时窗口的开头是L,下面的while工作是:R向右扩到违规为止 // R是最后一个达标位置的再下一个，通过下文的break终止 while (R < arr.length) { // R位置的数进入窗口后，最小值的更新结构和最大值的更新结构都要更新 while (!qmin.isEmpty() && arr[qmin.peekLast()] >= arr[R]) { qmin.pollLast(); } qmin.addLast(R); // R -> arr[R], while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[R]) { qmax.pollLast(); } qmax.addLast(R); // 如果此时不满足了，break。说明窗口已经成长到了第一个不达标的数进来了 if (arr[qmax.getFirst()] - arr[qmin.getFirst()] > num) { break; } R++; } // R是最后一个达标位置的再下一个，第一个违规的位置 res += R - L; // 检查最小值和最大值的更新结构有没有过期 if (qmin.peekFirst() == L) { qmin.pollFirst(); } if (qmax.peekFirst() == L) { qmax.pollFirst(); } // 窗口左边界向右滑动，窗口容量此时减1 L++; } return res; } // for test public static int[] getRandomArray(int len) { if (len < 0) { return null; } int[] arr = new int[len]; for (int i = 0; i < len; i++) { arr[i] = (int) (Math.random() * 10); } return arr; } // for test public static void printArray(int[] arr) { if (arr != null) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } } public static void main(String[] args) { int[] arr = getRandomArray(30); int num = 5; printArray(arr); System.out.println(getNum(arr, num)); } } ``` > 本题根据窗口滑动建立了单调性，上文的结论

1.1.6 如何优化一个问题？

1、 数据状况层面是否可以优化 2、 问题本身是否可以优化。单调性，首位指针（头指针往右走，尾指针往左走）等 > 遇到一个问题我们先观察，问题本身和范围是否可以建立单调性，至于需要用哪个原型来解决，串口和首位指针法是常见的流程。所以窗口和首位指针主要用来解决单调性的

1.2 单调栈

1.2.1 单调栈结构

在一个数组中，求每一个位置左边离它最近的比它小的数在哪，右边离它最近的比它小的数在哪。 例如[3, 2, 1, 7]。3左边比它小的最近的位置的数的位置没有，为-1，右边是1位置的2。2左边比它小的最近的位置的数的位置没有，为-1，右边是2位置的1等。 用一个map来记录，暴力解O(N^2)。单调栈能够在O(N)解决 单调栈算法流程： > 草稿纸上模拟这个栈; > 没有相等元素的情况：准备一个栈结构，暂定从小到大的单调栈结构。从左往右遍历我们的数组，[3,4,2,5]，由于栈空，第一个元素可以进栈，3进栈。 > 1位置的数4可以进栈，因为没有破坏从小到大的栈的单调性。 > 2位置的2无法直接进栈，因为会破坏栈的单调性。需要弹出栈元素，元素一旦被弹出，生成相应的记录。 > 1位置的4弹出，右边最近的比你小的数，就是谁让你弹出的数，所以4的右边最近的比4小的数是2。左边最近比你小的数，就是你在栈中压着的数，所以4的左边最近的比4小的数是3。 > 2位置的2此时仍然无法进栈，因为栈中此时还有3，那么3弹出。3的最近的右侧比3小的数是2，3是栈底元素，没有压着的元素，所以3左侧最近的比3小的数没有，位置置为-1。其他元素同理......。 > 最后如果没有元素了，栈中元素弹出，此时不是其他元素迫使的弹出，所以自然弹出的右侧最近比它小的无返回-1。左侧最近比它小的看它在栈中是否压着其他元素 可以选择任意位置去证明，证明略 > 如果存在相等元素的情况，我们栈中每个元素保存为list表示相等元素列表。无法直接进入单调栈时，弹出list最右侧的元素，该元素右侧最近的比自己小的数，就是迫使它弹出的那个数。该元素左侧最近比它小的数，就是自身的这个list压着的的list的最右的数。list的相同元素有两种情况，一种是两个数相等且挨着，另外一种是某个位置释放了中间位置的数后遇到相等元素，进入一个list中去。画栈模拟可看出 ```Java package class01; import java.util.List; import java.util.ArrayList; import java.util.Stack; public class Code03_MonotonousStack { // 数组中没有重复值的情况 public static int[][] getNearLessNoRepeat(int[] arr) { int[][] res = new int[arr.length][2]; Stack stack = new Stack<>(); for (int i = 0; i < arr.length; i++) { while (!stack.isEmpty() && arr[stack.peek()] > arr[i]) { int popIndex = stack.pop(); int leftLessIndex = stack.isEmpty() ? -1 : stack.peek(); res[popIndex][0] = leftLessIndex; res[popIndex][1] = i; } stack.push(i); } while (!stack.isEmpty()) { int popIndex = stack.pop(); int leftLessIndex = stack.isEmpty() ? -1 : stack.peek(); res[popIndex][0] = leftLessIndex; res[popIndex][1] = -1; } return res; } // arr [3, 2, 1, 4, 5] // 0 1 2 3 4 // 表示 0这个数左边最近比0小的没有，位置是-1，右边1。1位置数左边最近比0小的没有-1，右边2 // [ // 0 : [-1, 1 ] // 1 : [-1, 2 ] // ] // 数组中存在重复值的情况 public static int[][] getNearLess(int[] arr) { int[][] res = new int[arr.length][2]; // List -> 放的是位置，同样值的东西，位置压在一起 // 代表值 底 -> 顶 小 -> 大 Stack> stack = new Stack<>(); for (int i = 0; i < arr.length; i++) { // i -> arr[i] 进栈 // 栈底 -> 栈顶， 小 -> 大 while (!stack.isEmpty() && arr[stack.peek().get(0)] > arr[i]) { List popIs = stack.pop(); // 取位于下面位置的列表中，最晚加入的那个 int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1); for (Integer popi : popIs) { res[popi][0] = leftLessIndex; res[popi][1] = i; } } // 相等的、比你小的 if (!stack.isEmpty() && arr[stack.peek().get(0)] == arr[i]) { stack.peek().add(Integer.valueOf(i)); } else { ArrayList list = new ArrayList<>(); list.add(i); stack.push(list); } } while (!stack.isEmpty()) { List popIs = stack.pop(); // 取位于下面位置的列表中，最晚加入的那个 int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1); for (Integer popi : popIs) { res[popi][0] = leftLessIndex; res[popi][1] = -1; } } return res; } // for test public static int[] getRandomArrayNoRepeat(int size) { int[] arr = new int[(int) (Math.random() * size) + 1]; for (int i = 0; i < arr.length; i++) { arr[i] = i; } for (int i = 0; i < arr.length; i++) { int swapIndex = (int) (Math.random() * arr.length); int tmp = arr[swapIndex]; arr[swapIndex] = arr[i]; arr[i] = tmp; } return arr; } // for test public static int[] getRandomArray(int size, int max) { int[] arr = new int[(int) (Math.random() * size) + 1]; for (int i = 0; i < arr.length; i++) { arr[i] = (int) (Math.random() * max) - (int) (Math.random() * max); } return arr; } // for test public static int[][] rightWay(int[] arr) { int[][] res = new int[arr.length][2]; for (int i = 0; i < arr.length; i++) { int leftLessIndex = -1; int rightLessIndex = -1; int cur = i - 1; while (cur >= 0) { if (arr[cur] < arr[i]) { leftLessIndex = cur; break; } cur--; } cur = i + 1; while (cur < arr.length) { if (arr[cur] < arr[i]) { rightLessIndex = cur; break; } cur++; } res[i][0] = leftLessIndex; res[i][1] = rightLessIndex; } return res; } // for test public static boolean isEqual(int[][] res1, int[][] res2) { if (res1.length != res2.length) { return false; } for (int i = 0; i < res1.length; i++) { if (res1[i][0] != res2[i][0] || res1[i][1] != res2[i][1]) { return false; } } return true; } // for test public static void printArray(int[] arr) { for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } System.out.println(); } public static void main(String[] args) { int size = 10; int max = 20; int testTimes = 2000000; for (int i = 0; i < testTimes; i++) { int[] arr1 = getRandomArrayNoRepeat(size); int[] arr2 = getRandomArray(size, max); if (!isEqual(getNearLessNoRepeat(arr1), rightWay(arr1))) { System.out.println("Oops!"); printArray(arr1); break; } if (!isEqual(getNearLess(arr2), rightWay(arr2))) { System.out.println("Oops!"); printArray(arr2); break; } } } } ```

1.2.2 单调栈的应用

给定一个只包含正整数的数组arr，arr中任何一个子数组sub，一定都可以算出(sub累加和)*(sub中的最小值)是什么，那么所有子数组中，这个值最大是多少？ ```Java package class01; import java.util.Stack; public class Code04_AllTimesMinToMax { public static int max1(int[] arr) { int max = Integer.MIN_VALUE; for (int i = 0; i < arr.length; i++) { for (int j = i; j < arr.length; j++) { int minNum = Integer.MAX_VALUE; int sum = 0; for (int k = i; k <= j; k++) { sum += arr[k]; minNum = Math.min(minNum, arr[k]); } max = Math.max(max, minNum * sum); } } return max; } public static int max2(int[] arr) { int size = arr.length; int[] sums = new int[size]; sums[0] = arr[0]; for (int i = 1; i < size; i++) { sums[i] = sums[i - 1] + arr[i]; } int max = Integer.MIN_VALUE; Stack stack = new Stack(); for (int i = 0; i < size; i++) { while (!stack.isEmpty() && arr[stack.peek()] >= arr[i]) { int j = stack.pop(); max = Math.max(max, (stack.isEmpty() ? sums[i - 1] : (sums[i - 1] - sums[stack.peek()])) * arr[j]); } stack.push(i); } while (!stack.isEmpty()) { int j = stack.pop(); max = Math.max(max, (stack.isEmpty() ? sums[size - 1] : (sums[size - 1] - sums[stack.peek()])) * arr[j]); } return max; } public static int[] gerenareRondomArray() { int[] arr = new int[(int) (Math.random() * 20) + 10]; for (int i = 0; i < arr.length; i++) { arr[i] = (int) (Math.random() * 101); } return arr; } public static void main(String[] args) { int testTimes = 2000000; System.out.println("test begin"); for (int i = 0; i < testTimes; i++) { int[] arr = gerenareRondomArray(); if (max1(arr) != max2(arr)) { System.out.println("FUCK!"); break; } } System.out.println("test finish"); } } ```