单调队列单调栈 添加GO语言代码

animation-simulation/单调队列单调栈/leetcode739每日温度.md

@@ -65,4 +65,26 @@ class Solution {
 }
 ```
 
+**GO语言版本：**
+
+```go
+func dailyTemperatures(temperatures []int) []int {
+    l := len(temperatures)
+    if l == 0 {
+        return temperatures
+    }
+    stack := []int{}
+    arr   := make([]int, l)
+    for i := 0; i < l; i++ {
+        for len(stack) != 0 && temperatures[i] > temperatures[stack[len(stack) - 1]] {
+            idx := stack[len(stack) - 1]
+            arr[idx] = i - idx
+            stack = stack[: len(stack) - 1]
+        }
+        // 栈保存的是索引
+        stack = append(stack, i)
+    }
+    return arr
+}
+```
 

animation-simulation/单调队列单调栈/剑指offer59队列的最大值.md

@@ -101,4 +101,56 @@ class MaxQueue {
 }
 ```
 
+**GO语言版本：**
+
+```go
+type MaxQueue struct {
+    que []int	// 普通队列
+    deq []int	// 双端队列
+    size int	// que的队列长度
+}
+
+
+func Constructor() MaxQueue {
+    return MaxQueue{
+        que: []int{},
+        deq: []int{},
+    }
+}
+
+// Is_empty 表示队列是否为空
+func (mq *MaxQueue) Is_empty() bool {
+    return mq.size == 0
+}
+
+// Max_value 取最大值值，返回我们双端队列的对头即可，因为我们双端队列是单调递减的嘛 
+func (mq *MaxQueue) Max_value() int {
+    if mq.Is_empty() { return -1 }
+    return mq.deq[0]
+}
+
+// Push_back 入队
+func (mq *MaxQueue) Push_back(value int)  {
+    mq.que = append(mq.que, value)
+    // 维护单调递减队列
+    for len(mq.deq) != 0 && mq.deq[len(mq.deq) - 1] < value {
+        mq.deq = mq.deq[:len(mq.deq) - 1]
+    }
+    mq.deq = append(mq.deq, value)
+    mq.size++
+}
+
+// Pop_front 弹出队列头元素，并且返回其值。
+func (mq *MaxQueue) Pop_front() int {
+    if mq.Is_empty() { return -1 }
+    ans := mq.que[0]
+    mq.que = mq.que[1:]
+    if mq.deq[0] == ans {
+        mq.deq = mq.deq[1:]
+    }
+    mq.size--
+    return ans
+}
+```
+
 ### 

animation-simulation/单调队列单调栈/接雨水.md

@@ -119,13 +119,36 @@ class Solution {
 }
 ```
 
+**GO语言版本：**
 
+```go
+func trap(height []int) int {
+    stack := []int{}
+    water := 0
+    // 最左边部分不会接雨水，左边持续升高时，stack都会弹出所有元素。
+    for i := 0; i< len(height); i++ {
+        for len(stack) != 0 && height[i] > height[stack[len(stack) - 1]] {
+            popnum := stack[len(stack) - 1]
+            // 出现相同高度的情况（其实也可以不用处理，如果不处理，相同高度时后面的hig为0，会产生很多无效的计算）
+            for len(stack) != 0 && height[popnum] == height[stack[len(stack) - 1]] {
+                stack = stack[:len(stack) - 1]
+            }
+            if len(stack) == 0 { break }
+            le, ri := stack[len(stack) - 1], i
+            hig := min(height[ri], height[le]) - height[popnum]
+            wid := ri - le - 1
+            water += wid * hig
+        }
+        stack = append(stack, i)
+    }
+    return water
+}
 
-
-
-
-
-
+func min(a, b int) int {
+    if a < b { return a }
+    return b
+}
+```
 
 ### 
 

animation-simulation/单调队列单调栈/最小栈.md

@@ -79,4 +79,48 @@ class MinStack {
 }
 ```
 
+**GO语言版本：**
+
+```go
+type MinStack struct {
+    stack  []int
+    minStk []int
+}
+
+/** initialize your data structure here. */
+func Constructor() MinStack {
+    return MinStack{
+        stack:  []int{},
+        minStk: []int{},
+    }
+}
+
+// Push 入栈，如果插入值，当前插入值小于栈顶元素，则入栈，栈顶元素保存的则为当前栈的最小元素
+func (m *MinStack) Push(x int)  {
+    m.stack = append(m.stack, x)
+    if len(m.minStk) == 0 || m.minStk[len(m.minStk) - 1] >= x {
+        m.minStk = append(m.minStk, x)
+    }
+}
+
+// Pop 出栈，如果stack出栈等于minStk栈顶元素，则说明此时栈内的最小元素改变了。
+func (m *MinStack) Pop()  {
+    temp := m.stack[len(m.stack) - 1]
+    m.stack = m.stack[: len(m.stack) - 1]
+    if temp == m.minStk[len(m.minStk) - 1] {
+        m.minStk = m.minStk[: len(m.minStk) - 1]
+    }
+}
+
+// Top stack的栈顶元素
+func (m *MinStack) Top() int {
+    return  m.stack[len(m.stack) - 1]
+}
+
+// GetMin minStk的栈顶元素
+func (m *MinStack) GetMin() int {
+    return  m.minStk[len(m.minStk) - 1]
+}
+```
+
 ### 

animation-simulation/单调队列单调栈/滑动窗口的最大值.md

@@ -55,7 +55,7 @@ class Solution {
         }
         int[] arr = new int[len - k + 1];
         int arr_index = 0;
-        //我们需要维护一个单调递增的双向队列
+        //我们需要维护一个单调递减的双向队列
         Deque<Integer> deque = new LinkedList<>();
         for (int i = 0; i < k; i++) {
              while (!deque.isEmpty() && deque.peekLast() < nums[i]) {
@@ -79,3 +79,37 @@ class Solution {
 }
 ```
 
+**GO语言版本：**
+
+```go
+func maxSlidingWindow(nums []int, k int) []int {
+    l := len(nums)
+    if l == 0 {
+        return nums
+    }
+
+    arr   := []int{}
+    // 维护一个单调递减的双向队列
+    deque := []int{}
+    for i := 0; i < k; i++ {
+        for len(deque) != 0 && deque[len(deque) - 1] < nums[i] {
+            deque = deque[:len(deque) - 1]
+        }
+        deque = append(deque, nums[i])
+    }
+
+    arr = append(arr, deque[0])
+    for i := k; i < l; i++ {
+        if nums[i - k] == deque[0] {
+            deque = deque[1:]
+        }
+        for len(deque) != 0 && deque[len(deque) - 1] < nums[i] {
+            deque = deque[:len(deque) - 1]
+        }
+        deque = append(deque, nums[i])
+        arr = append(arr, deque[0])
+    }
+    return arr
+}
+```
+