GO--堆(have TODO)
堆
堆(Heap)是一种特殊的数据结构。它是一棵完全二叉树(完全二叉树是指除了最后一层外,每一层上的节点数都是满的,并且最后一层的节点都集中在左边),结放在数组(切片)中,通常分为最大堆(Max Heap)和最小堆(Min Heap)两种类型。
- 最大堆:在最大堆中,对于每个非叶子节点,它的值都大于或等于其左右子节点的值。也就是说,根节点的值是整个堆中的最大值。例如,对于节点
i
,如果它有左子节点2i + 1
和右子节点2i+2
(这里假设节点编号从 0 开始),那么heap[i]>=heap[2i + 1]
且heap[i]>=heap[2i+2]
。 - 最小堆:与最大堆相反,在最小堆中,对于每个非叶子节点,它的值都小于或等于其左右子节点的值。根节点的值是整个堆中的最小值。即对于节点
i
,heap[i]<=heap[2i + 1]
且heap[i]<=heap[2i+2]
。
堆的实现
1、使用container/heap包
heap源码中定义了一个Interface 的接口,此接口一共包含五个方法,我们定义一个实现此接口的类就实现了一个二叉堆
package main
import (
"container/heap"
"fmt"
)
type MaxHeap []int
func (m MaxHeap) Len() int {
return len(m)
}
func (m MaxHeap) Less(i, j int) bool {
//建立大根堆,使用>
return m[i] > m[j]
}
func (m *MaxHeap) Swap(i, j int) {
(*m)[i], (*m)[j] = (*m)[j], (*m)[i]
}
func (m *MaxHeap) Push(x any) {
*m = append(*m, x.(int))
}
func (m *MaxHeap) Pop() any {
//拿到堆顶元素
res := (*m)[len(*m)-1]
//删除堆顶元素
*m = (*m)[:len(*m)-1]
return res
}
func main() {
h := make(MaxHeap, 0)
//结构体实现了接口中的全部方法后,结构体也就是这个接口类型了,因此我们可以传入h
heap.Init(&h)
heap.Push(&h, 2)
heap.Push(&h, 1)
heap.Push(&h, 3)
fmt.Println(heap.Pop(&h))
fmt.Println(heap.Pop(&h))
fmt.Println(heap.Pop(&h))
}
下面我们一起去看看源码:
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package heap provides heap operations for any type that implements
// heap.Interface. A heap is a tree with the property that each node is the
// minimum-valued node in its subtree.
//
// The minimum element in the tree is the root, at index 0.
//
// A heap is a common way to implement a priority queue. To build a priority
// queue, implement the Heap interface with the (negative) priority as the
// ordering for the Less method, so Push adds items while Pop removes the
// highest-priority item from the queue. The Examples include such an
// implementation; the file example_pq_test.go has the complete source.
package heap
import "sort"
// The Interface type describes the requirements
// for a type using the routines in this package.
// Any type that implements it may be used as a
// min-heap with the following invariants (established after
// [Init] has been called or if the data is empty or sorted):
//
// !h.Less(j, i) for 0 <= i < h.Len() and 2*i+1 <= j <= 2*i+2 and j < h.Len()
//
// Note that [Push] and [Pop] in this interface are for package heap's
// implementation to call. To add and remove things from the heap,
// use [heap.Push] and [heap.Pop].
堆的接口,定义实现该接口内部的全部方法后,我们定义的类就实现了堆
下面是sort.Interface的实现,内部有三个方法,分别是Len()、Less()、Swap()
通过Less()方法,以此确定建立的是大根堆,还是小根堆
// An implementation of Interface can be sorted by the routines in this package.
// The methods refer to elements of the underlying collection by integer index.
type Interface interface {
// Len is the number of elements in the collection.
Len() int
// Less reports whether the element with index i
// must sort before the element with index j.
//
// If both Less(i, j) and Less(j, i) are false,
// then the elements at index i and j are considered equal.
// Sort may place equal elements in any order in the final result,
// while Stable preserves the original input order of equal elements.
//
// Less must describe a transitive ordering:
// - if both Less(i, j) and Less(j, k) are true, then Less(i, k) must be true as well.
// - if both Less(i, j) and Less(j, k) are false, then Less(i, k) must be false as well.
//
// Note that floating-point comparison (the < operator on float32 or float64 values)
// is not a transitive ordering when not-a-number (NaN) values are involved.
// See Float64Slice.Less for a correct implementation for floating-point values.
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
Swap(i, j int)
}
^
|
|
|
重点
type Interface interface {
sort.Interface
Push(x any) // add x as element Len()
Pop() any // remove and return element Len() - 1.
}
|
|
|
——
init方法,将实现接口的类init进行建堆
// Init establishes the heap invariants required by the other routines in this package.
// Init is idempotent with respect to the heap invariants
// and may be called whenever the heap invariants may have been invalidated.
// The complexity is O(n) where n = h.Len().
func Init(h Interface) {
// heapify
n := h.Len()
for i := n/2 - 1; i >= 0; i-- {
down(h, i, n)
}
}
Push插入元素
// Push pushes the element x onto the heap.
// The complexity is O(log n) where n = h.Len().
func Push(h Interface, x any) {
h.Push(x)
up(h, h.Len()-1)
}
Pop弹出元素
// Pop removes and returns the minimum element (according to Less) from the heap.
// The complexity is O(log n) where n = h.Len().
// Pop is equivalent to [Remove](h, 0).
func Pop(h Interface) any {
n := h.Len() - 1
h.Swap(0, n)
down(h, 0, n)
return h.Pop()
}
Remove移除元素
// Remove removes and returns the element at index i from the heap.
// The complexity is O(log n) where n = h.Len().
func Remove(h Interface, i int) any {
n := h.Len() - 1
if n != i {
h.Swap(i, n)
if !down(h, i, n) {
up(h, i)
}
}
return h.Pop()
}
Fix重新调整堆
// Fix re-establishes the heap ordering after the element at index i has changed its value.
// Changing the value of the element at index i and then calling Fix is equivalent to,
// but less expensive than, calling [Remove](h, i) followed by a Push of the new value.
// The complexity is O(log n) where n = h.Len().
func Fix(h Interface, i int) {
if !down(h, i, h.Len()) {
up(h, i)
}
}
堆调整的两个重要方法,up和down,具体我没看,我们可以自己写出更简单更好理解的heapInsert和heapify
func up(h Interface, j int) {
for {
i := (j - 1) / 2 // parent
if i == j || !h.Less(j, i) {
break
}
h.Swap(i, j)
j = i
}
}
func down(h Interface, i0, n int) bool {
i := i0
for {
j1 := 2*i + 1
if j1 >= n || j1 < 0 { // j1 < 0 after int overflow
break
}
j := j1 // left child
if j2 := j1 + 1; j2 < n && h.Less(j2, j1) {
j = j2 // = 2*i + 2 // right child
}
if !h.Less(j, i) {
break
}
h.Swap(i, j)
i = j
}
return i > i0
}
2、自己实现堆
自己实现堆,最重要的就是heapInsert和heapify方法,通过这两个方法,以此保证正确实现堆结构。
heapInsert方法:新来的一个元素,新来的元素若大于他的父节点元素,则上升,确定其应该在堆中的正确位置,实现大根堆
for循环虽然只有一个判断,却包含了另一层判断,当index到达0位置后,循环也会停止
func heapInsert(arr []int, index int) {
for arr[index] > arr[(index-1)/2] {
arr[index], arr[(index-1)/2] = arr[(index-1)/2], arr[index]
index = (index - 1) / 2
}
}
heapify方法,节点位置为最大值,实现大根堆
func heapify(arr []int, index int, heapsize int) {
//左孩子的位置
left := index*2 + 1
for left < heapsize {
//largest的含义为:节点和子节点中的最大值
largest := left //一开始放在左孩子上
//如果存在右孩子,并且右孩子的值比左孩子大,以此选出左右孩子中的较大节点
if left+1 < heapsize && arr[left] < arr[left+1] {
//在largest放在右孩子的位置
largest = left + 1
}
//判断largest和index节点位置谁大
if arr[index] > arr[largest] {
//若节点大于largest,则largest来到index位置
largest = index
}
//index位置为最大,则退出循环,不需要向下进行
if largest == index {
break
}
//交换节点位置
arr[largest], arr[index] = arr[index], arr[largest]
//index来到largest位置,继续下次循环
index = largest
//left继续来到左孩子的位置
left = index * 2 + 1
}
}
建堆
// 建堆
func buildHeap(arr []int) {
//从上至下建堆
//for i := 0; i < len(arr); i++ {
// heapInsert(arr, i)
//}
//从下至上建堆
for i := len(arr) - 1; i >= 0; i-- {
heapify(arr, i, len(arr))
}
}
堆排序
能够自己实现堆之后,实现堆排序就十分简单了。
若我们实现了大根堆,那么每次堆顶元素就是最大值,那么只需要堆顶与最后一个元素进行交换,交换后,堆的大小减1,然后在将交换后位于第一位的元素使用heapify让其下降,这样循环进行,最后堆的大小减到0,那么就实现了排序。
func heapSort(arr []int) {
heapSize := len(arr)
heapSize--
arr[0], arr[heapSize] = arr[heapSize], arr[0]
for heapSize > 0 {
heapify(arr, 0, heapSize)
heapSize--
arr[0], arr[heapSize] = arr[heapSize], arr[0]
}
}
Leetcode堆相关题目
(累了,下次再写)
1、215. 数组中的第K个最大元素 - 力扣(LeetCode)
求数组中第K大的元素,有很简单的方法,将数组进行排序,返回第k个数,即为第k大的数。
题目要求时间复杂度为O(N),可以使用桶排序,这道题目给了数据范围,确实可以用。
题解里还有改进的快速排序,也能达到O(N)的时间复杂度。
但我们主要还是使用堆来完成。
//题解标准答案
func findKthLargest(nums []int, k int) int {
//建立大根堆
buildHeap(nums)
heapSize := len(nums)
for i := len(nums) - 1; i >= len(nums)-k+1; i-- {
nums[0], nums[i] = nums[i], nums[0]
heapSize--
heapify(nums, 0, heapSize)
}
return nums[0]
}
//我觉得不好理解,就自己写了i从0——K,但是需要加判断,要不会出现nums[-1]的报错
func findKthLargest(nums []int, K int) int {
buildHeap(nums)
heapSize := len(nums)
nums[0], nums[heapSize-1] = nums[heapSize-1], nums[0]
for i:= 0; i < K; i++ {
heapSize--
heapify(nums,0,heapSize)
if heapSize-1 >= 0{
nums[0], nums[heapSize-1] = nums[heapSize-1], nums[0]
} else {
return nums[heapSize]
}
}
return nums[heapSize]
}
func heapify(arr []int, index int, heapsize int) {
//左孩子的位置
left := index*2 + 1
for left < heapsize {
//largest的含义为:节点和子节点中的最大值
largest := left //一开始放在左孩子上
//如果存在右孩子,并且右孩子的值比左孩子大,以此选出左右孩子中的较大节点
if left+1 < heapsize && arr[left] < arr[left+1] {
//在largest放在右孩子的位置
largest = left + 1
}
//判断largest和index节点位置谁大
if arr[index] > arr[largest] {
//若节点大于largest,则largest来到index位置
largest = index
}
//index位置为最大,则退出循环,不需要向下进行
if largest == index {
break
}
//交换节点位置
arr[largest], arr[index] = arr[index], arr[largest]
//index来到largest位置,继续下次循环
index = largest
//left继续来到左孩子的位置
left = index*2 + 1
}
}
func buildHeap(arr []int) {
//从上至下建堆
//for i := 0; i < len(arr); i++ {
// heapInsert(arr, i)
//}
//从下至上建堆
for i := len(arr) - 1; i >= 0; i-- {
heapify(arr, i, len(arr))
}
}
2、502. IPO - 力扣(LeetCode)
3、373. 查找和最小的 K 对数字 - 力扣(LeetCode)
TODO
4、295. 数据流的中位数 - 力扣(LeetCode)
TODO