数据结构及算法-堆

最新推荐文章于 2024-07-14 19:56:17 发布

爱思考的李MAX

最新推荐文章于 2024-07-14 19:56:17 发布

阅读量514

点赞数 14

文章标签：算法数据结构 go

本文链接：https://blog.csdn.net/l47ronin/article/details/139638024

版权

堆

概述

堆是一种满足特定条件的完全二叉树，主要可分为两种类型：

小顶堆：任意节点的值 ≤ 其子节点的值。
大顶堆：任意节点的值 ≥ 其子节点的值。

堆作为完全二叉树的一个特例，具有以下特性。

最底层节点靠左填充，其他层的节点都被填满。
我们将二叉树的根节点称为“堆顶”，将底层最靠右的节点称为“堆底”。
对于大顶堆（小顶堆），堆顶元素（根节点）的值是最大（最小）的。

堆通常用于实现优先队列，大顶堆相当于元素按从大到小的顺序出队的优先队列

堆的常用操作

方法名	描述	时间复杂度
posh()	元素入队	O(log n)
pop()	堆顶出队	O(log n)
peek()	堆顶元素	O(1)
size()	获得堆的数量	O(1)
isempty()	堆是否为空	O(1)

在实际应用中，我们可以直接使用编程语言提供的堆类（或优先队列类）。类似于排序算法中的“从小到大排列”和“从大到小排列”，我们可以通过设置一个 flag 或修改 Comparator 实现“小顶堆”与“大顶堆”之间的转换。

/*head.go*/

//go语言通过heap.interface来构建大顶堆的

/* 构建整数大堆 */
type intheap []any


//通过Push heap.Interface的方式，实现推入元素到堆
func (h *intHeap) Push(x any){
    *h = append(*h,x.(int))            
}

// Pop heap.Interfance的方法，实现弹出堆顶元素
                
func (h *intheap) Pop() any{
    last :=(*h)[len(*h)-1]
    *h = (*h)[:len(*h)-1]
    return last
}

//Less 就是去计算堆的元素个数
func(h *intheap) Len() int{
    return len(*h)
} 


//less 排序
func(h *intHeap) Less(i,j int) bool{
    return (*h)[i].(int) > (*h)[j].(int)
//如果实现小顶堆，则需要调整为<号
}

//交换堆元素位置
func(h *intheap) Swap(i,j int){
    (*h)[i],(*h)[j] = (*h)[j],(*h)[i]
}

//获取堆顶元素
func (h *inthaep) Top() any{
    return (*h)[0]
}


//此为测试函数，以测试为驱动
func TestHeap(t *testing.T){
    maxHeap := &intHeap{}
    heap.Init(maxHeap)
    heap.Push(maxHeap,1)
    heap.Push(maxHeap,2)
    heap.Push(maxHeap,3)
    heap.Push(maxHeap,4)
    heap.Push(maxHeap,5)
    top := maxHeap.Top()
    fmt.Printf("堆顶元素"，top)
    
    head.Pop(maxHeap)
    head.Pop(maxHeap)
    head.Pop(maxHeap)
    head.Pop(maxHeap)
    head.Pop(maxHeap)
    size :=len(*maxHeap)
    fmt.Println("堆元素数量为"，size)
    
}

堆的实现

若要将其转换为小顶堆，只需将所有大小逻辑判断取逆（例如，将 ≥ 替换为 ≤ ）。

堆的存储与表示

完全二叉树非常适合用数组来表示。由于堆正是一种完全二叉树，因此我们将采用数组来存储堆。
当使用数组表示二叉树时，元素代表节点值，索引代表节点在二叉树中的位置。节点指针通过索引映射公式来实现。

给定索引 i，其左子节点的索引为 2i+ 1 ，右子节点的索引为 2i+ 2 ，父节点的索引为 (i− 1)/2（向下整除）。当索引越界时，表示空节点或节点不存在。

接下来我们书写函数

/*获取左子节点的索引*/

func (h *maxHeap) left(i int) int{
    return 2*i + 1
}

/*获取右子节点*/
func(h *maxHeap) right(i int) int {
    return 2*i + 2
}

/*获取父节点*/ parent(i int) int {
    //此步是向下整除
    return (i-1) / 2
}

/*访问堆顶元素*/
func(h *maxheap) peek() any{
    return h.data[0]
}

元素入堆

/* 元素入堆*/
func (h *maxHeap) push(val any){
    h.data = append(h.data,val)
    h.sifUp(len(h.data) - 1)
}

/* 从节点i开始，从底至顶堆化*/
func(h *maxHeap) sifUp(i int){
    for {
        //获取节点i的父节点
        p:=h.parent(i)
        //当越过根节点或节点无需修复，就结束
        if p<0 || h.data[i].(int) <= h.data[p].(int){
            break
        }
        //交换两个的值
        h.swap(i,p)
        //循环向上堆化
        i = p
    } 
}

堆顶元素出堆

将堆顶与对位进行交换，然后其他元素，在从上至下交换

/*元素出堆*/
func(h *maxHeap)pop() any{
    //判空处理
    if h.isEmpty(){
        fmt.Println("error")
        return nil
    }
    h.swap(0,h.size-1) //交换首尾元素
    value := h.data[len(h.data)-1]
    h.data = h.data[:len(h.data)-1]
    h.siftDown(0) //从顶端至底堆化
    return val //返回堆顶元素
}

/*从节点i开始，从顶至底堆化*/

func (h *maxheap) siftDown(i int){
    for {
        //判断节点i，l,r中最大的节点，记max
        l,r,max :=h.left(),h.right(i),i
        if l<h.size()&& h.data[l].(int) > h.data[max].(int){
            max = l
        }
        if r < h.size() && h.data[r].(int) > h.data[max].(int){
            max = r
        }
        //当i为最大，就无法继续推了
        if max == i{
            break
        }
        //交换两节点
        h.swap(i,max)
    	//循环向下堆化
    	i=max
    }
}

堆的常见应用

优先队列：堆通常作为实现优先队列的首选数据结构，其入队和出队操作的时间复杂度均为 O(logn) ，而建队操作为 O(n) ，这些操作都非常高效。
堆排序：给定一组数据，我们可以用它们建立一个堆，然后不断地执行元素出堆操作，从而得到有序数据
获取最大的 K个元素：这是一个经典的算法问题，同时也是一种典型应用，例如选择热度前 10 的新闻作为微博热搜，选取销量前 10 的商品等。

图

代码实现

/*基于领阶矩阵实现的无向图*/

type graphAdjmat struct{
    //顶点列表，元素代表值，索引代表“顶点索引”
    vertices []int
    //领接矩阵，行列索引对应“顶点索引”
    adjMat [][]int
}

/* 构造函数 */

func newGraphAdjMat(version []int,edges [][]int) *graphAdjMat{
    //添加顶点
    n :=len(verstices)
    adjmat :=make([][]int,n)
    for i := range adjMat{
        adjMat[i] = make([]int,n)
    }
    // 初始化图
    g := &grapAdjMat{
        vertices: vertices,
        adjMat: adjMat,
    }
    for i := range edges {
        g.addEdge(edges[i][0],edges[i][1])
    }
    return g
}

func (g *grapAdjMat) size() int {
    return len(g.vertices)
}

func (g *graphAdjMat) addertex(val int){
    n := g.size()
    g.vertices = append(g.vertices,val)
    newRow := make([]int,n)
    g.adjMat = append(g.adjMat,newRow)
    for i:= range g.adjMat{
        g.adjMat[i] = append(g.adjMat[i],0)
    }
}

/*删除顶点*/
func(g *graphAdjMat) removeVertex(index int) {
    if index >= g.size(){
        return
    }
    g.vertices = append(g.vertices[:index],g.vertices[index+1:]...)
    g.adjMat = append(g.adjMat[:index],g.adjMat[index+1:]...)
    for i:=range g.adjMat{
        g.adjMat[i] = append(g.adjMat[i][:index],g.adjMat[i][index+1]...)
    }
}

/*添加边*/
//参数i，j对应vertices元素索引
func(g *grapAdjMat) addEdge(i,j int){
    //索引越界与相等处理
    if i<0||j<0 || i>=g.size()||j>=g.size()|| i==j{
        fmt.Errorf("%s","Index Out Of Bounds Exception")
    }
    //在无向图中，邻接矩阵关于主队角线对称,既满足(i,j) == (j,i)
    g.adjMat[i][j]=1
    g.adjMat[j][i]=1
}

/*删除边*/

//参数i，j对应vertices元素索引
func (g *grapAdjMat) remove(i,j int){
    if i<0 || j<0 || i>=g.size()||j>=g.size()||i==j{
        fmt.Errorf("%s","Index Out Of Bounds Exception")
    }
    g.adjMat[i][j] = 0
    g.adjMat[j][i] = 0
}

/*打印邻接矩阵*/
func (g *grapAdjMat) Print(){
    fmt.Print("\t顶点列表=%v\n",g.vertices)
    fmt.Printf("\t领接矩阵=\n")
    for i:=range g.adjMat{
        fmt.printf("\t\t\t%v\n",g.adjMat[i])
    }
}

二分查找

func binarysearch(nums []int target int) int {
i,j := 0,len(size) -1
for i<=j{
	m := (i+j)/2
	if target < nums[m]{
	i = m+1
	}else if target > nums[m]{
	j = m-1
	}else{
	return m
	}
	}
	return -1 //未找到target
}
}

二分查找插入点

func binarySearchInsert(nums []int,target int) int{
    i,j := 0,len(size)-1
    for i<=j{
        m := (j-1)/2
        if nums[m] < target{
            i = m +1
        } else if nums[m] > target{
            j = m -1
        }else{
            return m
        }
    }
}

二分查找出入点（重复值的）

func binarySearchInsertion(nums []int,targer int) int{
    i,j := 0,len(nums)-1
    for i<=j{
        m := (j-i)/2
        if nums[m] < target{
            i = m+1
        }else if nums[m]>target{
            j = m-1
        }else{
            j = m-1
        }
    }
    return i
}

二分查找的左边界

func binarySearchleft(nums []int,target int) int {
i := binarySearchInsertion(nums[],target)
if i == len(nums) || nums[i] != target{
	return -1
}
return i
}

爱思考的李MAX

关注

14
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
数据结构及算法-堆

堆是一种满足特定条件的完全二叉树，主要可分为两种类型：小顶堆：任意节点的值 ≤ 其子节点的值。大顶堆：任意节点的值 ≥ 其子节点的值。堆作为完全二叉树的一个特例，具有以下特性。最底层节点靠左填充，其他层的节点都被填满。我们将二叉树的根节点称为“堆顶”，将底层最靠右的节点称为“堆底”。对于大顶堆（小顶堆），堆顶元素（根节点）的值是最大（最小）的。堆通常用于实现优先队列，大顶堆相当于元素按从大到小的顺序出队的优先队列。
复制链接

扫一扫