max window

Author: dairongpeng

13-《进阶》单调栈和窗口.md

@@ -34,7 +34,7 @@
 
 3、我们窗口结构一直被维护，双端队列右边进，左边出。那么窗口的最大值就是我们双端队列最左侧（头部）的值
 
-==双端队列结构实质上指的是：如果此时形成的窗口状况，不想让R往右动了，而让L往右动。谁会以此成为最大值的优先级。为什么弹出的数不再找回，原因是在窗口滑动的过程中，被弹出的数的优先级已经被后来的大数取代了，这就是尾端加入，前一个数比当前数小则弹出，比当前数大就加入当前数的道理==
+双端队列结构实质上指的是：如果此时形成的窗口状况，不想让R往右动了，而让L往右动。谁会以此成为最大值的优先级。为什么弹出的数不再找回，原因是在窗口滑动的过程中，被弹出的数的优先级已经被后来的大数取代了，这就是尾端加入，前一个数比当前数小则弹出，比当前数大就加入当前数的道理
 
 
 > 反之，如果我们要窗口内最小值，只需要维护我们的双端队列单调递增的，既由小到大的即可
@@ -44,129 +44,78 @@
 
 ### 1.1.4 高频题：求滑动窗口最大值
 
-假设一个固定大小为W的窗口，以此划过arr，返回每一次划出状况的最大值
+假设一个固定大小为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;
+```Go
+package main
 
-import java.util.LinkedList;
-
-public class Code01_SlidingWindowMaxArray {
+import (
+	"container/list"
+	"fmt"
+)
 
-	public static int[] getMaxWindow(int[] arr, int w) {
-		if (arr == null || w < 1 || arr.length < w) {
-			return null;
-		}
-		
-		// Java中LinkedList就是双端队列，双向链表
-		// 其中放的是下标位置，头代表 （大->小）尾
-		LinkedList<Integer> qmax = new LinkedList<Integer>();
-		// 窗口在滑动的过程中，最终会生成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;
+// getMaxWindow arr 是数据样本 w是窗口大小
+func getMaxWindow(arr []int, w int) []int {
+	if len(arr) == 0 || w < 1 || len(arr) < w {
+		return nil
 	}
 
-	// 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]);
-
+	// 双向链表
+	// 其中放的是下标位置，头代表 （大->小）尾
+	qmax := list.List{}
+	// 窗口在滑动的过程中，最终会生成arr长度-窗口起始宽度+1个值
+	res := make([]int, len(arr) - w + 1)
+	index := 0
+	// 双端队列的头部元素
+	var fe = &list.Element{}
+	// 双端队列的尾部元素
+	var ee = &list.Element{}
+	// L...R
+	//     R
+	for R := 0; R < len(arr); R++ { // 当前让 i -> [i] 进窗口 ， i 就是 r
+		// R 位置的值  可以放在比他大的数后，或者空
+		// 双端队列不为空，且双端队列尾部的值小于当前要进入窗口的值
+		for qmax.Len() != 0 && arr[qmax.Back().Value.(int)] <= arr[R] {
+			// 双端队列从尾部弹出
+			qmax.Remove(ee)
+			if qmax.Len() > 0 {
+				ee = qmax.Back()
+				fe = qmax.Front()
 			}
-			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));
+		// 经过上述的while，最终把当前进入窗口的数放入双端队列的尾部
+		qmax.PushBack(R)
+		fe = qmax.Front()
+		ee = qmax.Back()
+		// 数进来了
+		// 如果窗口没有形成W的长度之前，不弹出数字的
+		// 当前下标是R, R-W就是需要过期的下标。
+		// 如果双端队列的头部保存的下标等于R-W，就头部弹出。实质R-W就是我们原始结构的L下标
+		if qmax.Front().Value.(int) == R - w {
+			qmax.Remove(fe)
 		}
-		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;
-			}
+		// 以上窗口更新做完了
+		// 窗口没有形成W长度之前，不收集答案。形成W长度后，每一次收集一个答案
+		if R >= w -1 {
+			res[index] = arr[qmax.Front().Value.(int)]
+			index++
 		}
-		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");
-	}
-
+	return res
 }
 
+func main() {
+	arr := []int{4, 3, 5, 4, 3, 3, 6, 7}
+	w := 3
+	fmt.Println(getMaxWindow(arr, w))
+}
 ```
 
 ### 1.1.5 高频题二：达标子数组数量问题