add maxSlidingWindow

Author: beyondyyh

algorithms/README.md

@@ -73,4 +73,5 @@
 |22|[链表中倒数第k个节点](https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/)|[go](./offer100/22.getKthFromEnd.go)|S|
 |40|[最小的k个数](https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/)|[go](./offer100/40.getLeastNumbers.go)|S|
 |58|[左旋转字符串](https://leetcode-cn.com/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/)|[go](./offer100/58.reverseLeftWords.go)|S|
+|239|[滑动窗口最大值](https://leetcode-cn.com/problems/sliding-window-maximum/)|[go](./offer100/239.maxSlidingWindow.go)|M|
 ||||[:top:](#Top)|

algorithms/offer100/22.getKthFromEnd_test.go

@@ -22,7 +22,7 @@ func Test_getKthFromEnd(t *testing.T) {
 			Input: []interface{}{
 				[]int{1, 2, 3, 4, 5}, 4,
 			},
-			Expected: []int{1, 2, 3, 4, 5},
+			Expected: []int{2, 3, 4, 5},
 		},
 	}
 

algorithms/offer100/239.maxSlidingWindow.go

@@ -0,0 +1,116 @@
+package offer100
+
+// 给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
+// 返回滑动窗口中的最大值。
+// 示例 1：
+// 输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
+// 输出：[3,3,5,5,6,7]
+// 解释：
+// 滑动窗口的位置                最大值
+// ---------------               -----
+// [1  3  -1] -3  5  3  6  7       3
+//  1 [3  -1  -3] 5  3  6  7       3
+//  1  3 [-1  -3  5] 3  6  7       5
+//  1  3  -1 [-3  5  3] 6  7       5
+//  1  3  -1  -3 [5  3  6] 7       6
+//  1  3  -1  -3  5 [3  6  7]      7
+// Leetcode ：https://leetcode-cn.com/problems/sliding-window-maximum
+
+// 可以采用最大堆的数据结构来保存元素，堆顶元素即为当前堆的最大值，并判断当前堆顶元素这是否在窗口中，
+// 在则直接返回，不在则利用堆特性删除堆顶元素并调整堆
+// 时间复杂度：O(N logN)， n=len(nums)
+
+import (
+	"container/heap"
+	"fmt"
+)
+
+type Item struct {
+	index int // 元素下标
+	value int // 元素值
+}
+
+// 声名一个优先队列，java的优先队列就是用堆实现的
+type PriorityQueue []*Item
+
+// 实现heap接口的 Len,Less,Swap,Push,Pop 方法
+func (pq PriorityQueue) Len() int {
+	return len(pq)
+}
+
+// 比较器，当两者的值相同时，比较下标的位置
+func (pq PriorityQueue) Less(i, j int) bool {
+	if pq[i].value == pq[j].value {
+		return pq[i].index > pq[j].index
+	}
+	return pq[i].value > pq[j].value
+}
+
+func (pq PriorityQueue) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+}
+
+// Push、Pop不仅改变堆的值还改变堆长度，所以receiver用指针
+func (pq *PriorityQueue) Push(x interface{}) {
+	// n := len(*pq)
+	item := x.(*Item)
+	// item.index = n
+	*pq = append(*pq, item)
+}
+
+func (pq *PriorityQueue) Pop() interface{} {
+	old := *pq
+	n := len(old)
+	item := old[n-1]
+	old[n-1] = nil // 避免内存泄露
+	*pq = old[0 : n-1]
+	return item
+}
+
+// 只查看堆顶元素，不更改堆的结构，此处是大顶堆所以第一个元素最大
+func (pq PriorityQueue) peek() interface{} {
+	return pq[0]
+}
+
+func dump(pq PriorityQueue) {
+	nums := make([]Item, 0)
+	for _, v := range pq {
+		nums = append(nums, *v)
+	}
+	fmt.Printf("pq: %+v\n", nums)
+}
+
+// -----
+func maxSlidingWindow(nums []int, k int) []int {
+	// 初始化前K的元素到堆中
+	pq := make(PriorityQueue, k)
+	for i := 0; i < k; i++ {
+		pq[i] = &Item{index: i, value: nums[i]}
+	}
+	heap.Init(&pq)
+	// dump(pq)
+
+	n := len(nums)
+	// 总共有n-k+1个窗口，声名一个长度长度&容量n-k+1的slice
+	ans := make([]int, n-k+1)
+	// 堆顶元素即是第一个窗口最大值，先放进ans
+	ans[0] = pq.peek().(*Item).value
+
+	// 遍历将剩下的元素依次入堆
+	for i := k; i < n; i++ {
+		// 将新元素入堆
+		item := &Item{index: i, value: nums[i]}
+		heap.Push(&pq, item)
+		// 循环判断当前堆顶是否在窗口中，一般思路是遍历窗口元素与堆顶进行对比，时间复杂度为O(k)
+		// 反向思维：堆顶元素已经是最大值，可以依次pop比较堆顶元素的下标是否小于窗口的左边界i-k+1，直到堆为空或者堆顶元素下标等于左边界，出栈时间复杂度O(1)
+		for pq.Len() > 0 && pq.peek().(*Item).index <= i-k {
+			heap.Pop(&pq)
+		}
+		// 在窗口中直接赋值即可
+		if pq.Len() > 0 {
+			ans[i-k+1] = pq.peek().(*Item).value
+		}
+	}
+	// dump(pq)
+	return ans
+}

algorithms/offer100/239.maxSlidingWindow_test.go

@@ -0,0 +1,65 @@
+package offer100
+
+import (
+	"reflect"
+	"testing"
+)
+
+type (
+	entry239input struct {
+		nums []int
+		k    int
+	}
+	entry239 struct {
+		name     string
+		input    entry239input
+		expected []int
+	}
+)
+
+// run: go test -run Test_maxSlidingWindow
+func Test_maxSlidingWindow(t *testing.T) {
+	cases := []entry239{
+		{
+			name: "x1",
+			input: entry239input{
+				nums: []int{1, 3, -1, -3, 5, 3, 6, 7},
+				k:    3,
+			},
+			expected: []int{3, 3, 5, 5, 6, 7},
+		},
+		{
+			name: "x2",
+			input: entry239input{
+				nums: []int{1},
+				k:    1,
+			},
+			expected: []int{1},
+		},
+		{
+			name: "x3",
+			input: entry239input{
+				nums: []int{1, -1},
+				k:    1,
+			},
+			expected: []int{1, -1},
+		},
+		{
+			name: "x4",
+			input: entry239input{
+				nums: []int{9, 11},
+				k:    2,
+			},
+			expected: []int{11},
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			output := maxSlidingWindow(c.input.nums, c.input.k)
+			if !reflect.DeepEqual(output, c.expected) {
+				t.Errorf("maxSlidingWindow(%v,%d)=%v, expected=%v", c.input.nums, c.input.k, output, c.expected)
+			}
+		})
+	}
+}

algorithms/offer100/40.getLeastNumbers_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 )
 
-// run: go test -run -v Test_getLeastNumbers
+// run: go test -run Test_getLeastNumbers
 func Test_getLeastNumbers(t *testing.T) {
 	cases := []CaseEntry{
 		{