栈堆

20 有效括号

func isValid(s string) bool {
	dists := map[byte]byte{
		'(': ')',
		'[': ']',
		'{': '}',
	}

	arr := []byte{}
	for i := 0; i < len(s); i++ {
		if _, ok := dists[s[i]]; ok {
			arr = append(arr, dists[s[i]])
			continue
		}
		if len(arr) == 0 || arr[len(arr)-1] != s[i] {
			return false
		}
		arr = arr[:len(arr)-1]
	}
	if len(arr) != 0 {
		return false
	}
	return true
}

84 柱中图中最大的矩形

// 暴力求解
// 矩形的面积为 height * width
// 已知 height 求 width, 每次循环左右边界获取 width
func largestRectangleArea(heights []int) int {
	maxArea := 0
	for i := 0; i < len(heights); i++ {
		left, right := i, i
		for left-1 >= 0 && heights[left-1] >= heights[i] {
			left--
		}
		for right+1 < len(heights) && heights[right+1] >= heights[i] {
			right++
		}
		maxArea = max(maxArea, heights[i]*(right-left+1))
	}
	return maxArea
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}


使用栈
func largestRectangleArea(heights []int) int {
	statck := []int{}
	maxArea := 0
	heights = append(heights, -1)
	for i := 0; i < len(heights); {
		if len(statck) == 0 || heights[i] > heights[statck[len(statck)-1]] {
			statck = append(statck, i)
			i++
			continue
		}
		top := statck[len(statck)-1]
		statck = statck[:len(statck)-1]
		width := 0
                // 栈为空说明左边没有更高的元素
		if len(statck) == 0 {
			width = i
		} else {
			width = i - statck[len(statck)-1] - 1
		}
		area := width * heights[top]
		if area > maxArea {
			maxArea = area
		}
	}
	return maxArea
}

堆

239. 滑动窗口最大值

func maxSlidingWindow(nums []int, k int) []int {
	h := &IHeap{}
	heap.Init(h)
	ans := []int{}

	for i := 0; i < len(nums); i++ {
		heap.Push(h, Element{i, nums[i]})
		if i >= k-1 {
			for (*h)[0].index < i-k+1 {
				heap.Pop(h)
			}
			ans = append(ans, (*h)[0].val)
		}
	}
        
	return ans
}

type Element struct {
	index int
	val   int
}

type IHeap []Element

func (h IHeap) Len() int {
	return len(h)
}

func (h IHeap) Less(i, j int) bool {
	if h[i].val == h[j].val {
		return h[i].index > h[j].index
	}
	return h[i].val > h[j].val
}

func (h IHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]
}

func (h *IHeap) Push(x interface{}) {
	*h = append(*h, x.(Element))
}

func (h *IHeap) Pop() interface{} {
	old := *h
	x := old[len(old)-1]
	*h = old[:len(old)-1]
	return x
}

347. 前 K 个高频元素

func topKFrequent(nums []int, k int) []int {
	ans := []int{}

	dists := map[int]int{}
	for _, num := range nums {
		dists[num]++
	}

	h := &MaxHeap{}
	heap.Init(h)
	for num, i := range dists {
		heap.Push(h, Element{num, i})
	}

	for i := 0; i < k; i++ {
        ans = append(ans, heap.Pop(h).(Element).index)
	}
	return ans
}

type Element struct {
	index int
	val   int
}

type MaxHeap []Element

func (h MaxHeap) Len() int {
	return len(h)
}

func (h MaxHeap) Less(i, j int) bool {
	return h[i].val > h[j].val
}

func (h MaxHeap) Swap(i, j int) {
	h[i], h[j] = h[j], h[i]
}

func (h *MaxHeap) Push(x interface{}) {
	*h = append(*h, x.(Element))
}

func (h *MaxHeap) Pop() interface{} {
	old := *h
	x := old[len(old)-1]
	*h = old[:len(old)-1]
	return x
}