堆（Heap）与优先队列

最新推荐文章于 2024-07-24 23:21:08 发布
最新推荐文章于 2024-07-24 23:21:08 发布
阅读量73 收藏
点赞数
文章标签： 数据结构 算法 c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45061460/article/details/131786617
版权

堆的基础知识

可以把堆看作一个数组，也可以被看作一个完全二叉树，通俗来讲堆其实就是利用完全二叉树的结构来维护的一维数组

  • 大顶堆：每个结点的值都大于或等于其左右孩子结点的值
  • 小顶堆：每个结点的值都小于或等于其左右孩子结点的值

堆排序的口诀

  1. 将堆顶元素与堆尾元素交换
  2. 将此操作看作是堆顶元素弹出操作
  3. 按照头部弹出以后的策略调整堆

堆-优先队列

普通队列（最大/最小）堆
尾部入队尾部可以插入
头部出队列头部可以弹出
先进先出每次出队权值（最大/最小的元素）
数组实现数组实现，逻辑上看成一个堆

实现

#define MAX_N 1000;
int data[MAX_N + 5], cnt = 0;
void shift_up(int ind){
	while(ind && data[(ind - 1)/2] < data[ind]){
		swap(data[(ind - 1)/2], data[ind]);
		ind = (ind - 1)/2;
	}
	return;
}
void shift_down(int ind){
	int n = cnt - 1;
	while(ind * 2 + 1 <= n){
		int tamp = ind;
		if(data[temp] < data[ind * 2]+1) temp = ind * 2 + 1;
		if(ind * 2 + 2 <= n && data[temp] < data[ind * 2 + 2]) temp = ind * 2 + 2;
		if(temp == ind) break;
		swap(data[temp], data[ind]);
		ind = temp;
	}
	return
}
void push(int x){
	data[cnt++] = x;
	shift_up(cnt - 1);
	return;
}
void pop(){
	if(size() == 0) return;
	swap(data[0], data[cnt - 1]);
	cnt -= 1;
	shift_down(0);
	return;
}
int top(){
	return data[0];
}
int size(){
	return cnt;
}
int main(){
	int op, val;
	while(cin >> op){
		switch(op){
			case 0: cin>>val; printf("push %d to head \n"); push(val); break;
			case 1: printf("pop %d from heap \n", top()); pop(); break;
		}
	}
	return 0;
}

template<typename T>
class Heap : public vector<T>{
    public:
        template<typename Func_T>
        Heap(Func_T cmp) : cmp(cmp) {}
        void push(const T &a){
            this->push_back(a);
            push_heap(this->begin(), this->end(), cmp);
            return ;
        }
        void pop(){
            pop_heap(this->begin(), this->end(), cmp);
            this->pop_back();
            return ;
        }
        T &top() {return this->at(0); }
    private:
         function<bool(T, T)> cmp;
};

一句话理解堆
堆适合维护：集合最值

经典面试题 - 堆的基础应用

剑指 Offer 40. 最小的k个数

class Solution {
public:
    template<typename T>
    class Heap : public vector<T>{
        public:
            template<typename Func_T>
            Heap(Func_T cmp) : cmp(cmp) {}
            void push(const T &a){
                this->push_back(a);
                push_heap(this->begin(), this->end(), cmp);
                return ;
            }
            void pop(){
                pop_heap(this->begin(), this->end(), cmp);
                this->pop_back();
                return ;
            }
            T &top() {return this->at(0); }
            private:
                function<bool(T, T)> cmp;
    };

    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        Heap<int> h{less<int>()};
        for(auto x: arr){
            h.push(x);
            if(h.size() > k) h.pop();
        }
        return h;
    }
};

1046. 最后一块石头的重量

class Solution {
public:
    template<typename T>
    class Heap : public vector<T>{
        public:
            template<typename Func_T>
            Heap(Func_T cmp) : cmp(cmp) {}
            void push(const T &a){
                this->push_back(a);
                push_heap(this->begin(), this->end(), cmp);
                return ;
            }
            void pop(){
                pop_heap(this->begin(), this->end(), cmp);
                this->pop_back();
                return ;
            }
            T &top() {return this->at(0); }
            private:
                function<bool(T, T)> cmp;
    };
    int lastStoneWeight(vector<int>& stones) {
        Heap<int> h{less<int>()};
        for(auto x: stones){
            h.push(x);
        }
        while(h.size() > 1){
            int y = h.top(); h.pop();
            int x = h.top(); h.pop();
            if(x == y) continue;
            h.push(y - x);
        }
        if(h.size() == 0) return 0;
        return h.top();
    }
};

703.数据流中的第k大元素

class KthLargest {
public:
    template<typename T>
    class Heap : public vector<T>{
        public:
            template<typename Func_T>
            Heap(Func_T cmp) : cmp(cmp) {}
            void push(const T &a){
                this->push_back(a);
                push_heap(this->begin(), this->end(), cmp);
                return ;
            }
            void pop(){
                pop_heap(this->begin(), this->end(), cmp);
                this->pop_back();
                return ;
            }
            T &top() {return this->at(0); }
        private:
            function<bool(T, T)> cmp;
    };
    
    Heap<int> h{greater<int>()};
    int k;
    KthLargest(int k, vector<int>& nums) :k(k) {
        for(auto x: nums){
            add(x);
        }
        return;
    }
    
    int add(int val) {
        h.push(val);
        if(h.size() > k) h.pop();
        return h.top();
    }
};

215.数组中的第k个最大元素

class Solution {
public:
    template<typename T>
    class Heap : public vector<T>{
        public:
            template<typename Func_T>
            Heap(Func_T cmp) : cmp(cmp) {}
            void push(const T &a){
                this->push_back(a);
                push_heap(this->begin(), this->end(), cmp);
                return ;
            }
            void pop(){
                pop_heap(this->begin(), this->end(), cmp);
                this->pop_back();
                return ;
            }
            T &top() {return this->at(0); }
        private:
            function<bool(T, T)> cmp;
    };

    int findKthLargest(vector<int>& nums, int k) {
        Heap<int> h{greater<int>()};
        for(auto x: nums){
            h.push(x);
            if(h.size() > k) h.pop();
        }
        return h.top();
    }
};

692. 前K个高频单词

class Solution {
public:
    template<typename T>
    class Heap : public vector<T>{
        public:
            template<typename Func_T>
            Heap(Func_T cmp) : cmp(cmp) {}
            void push(const T &a){
                this->push_back(a);
                push_heap(this->begin(), this->end(), cmp);
                return ;
            }
            void pop(){
                pop_heap(this->begin(), this->end(), cmp);
                this->pop_back();
                return ;
            }
            T &top() {return this->at(0); }
        private:
            function<bool(T, T)> cmp;
    };
    vector<string> topKFrequent(vector<string>& words, int k) {
        unordered_map<string, int> freq;
        for(auto x: words) freq[x] += 1;
        auto cmp = [&freq](string a, string b) ->bool {
            if(freq[a] - freq[b]) return freq[a] > freq[b];
            return a < b;
        };
        Heap<string> h{cmp};
        for(auto x: freq){
            h.push(x.first);
            if(h.size() > k) h.pop();
        }
        sort(h.begin(), h.end(), cmp);
        return h;
    }
};

296.数据流的中位数
对顶堆：将数据分为两半，前半段的最后一个是前半段的最大值，后半段的第一个是后半段的最小值，演变成一个小顶堆和一个大顶堆的管理


class MedianFinder {
public:
    template<typename T>
    class Heap : public vector<T>{
        public:
            template<typename Func_T>
            Heap(Func_T cmp) : cmp(cmp) {}
            void push(const T &a){
                this->push_back(a);
                push_heap(this->begin(), this->end(), cmp);
                return ;
            }
            T pop(){
                T ret = top();
                pop_heap(this->begin(), this->end(), cmp);
                this->pop_back();
                return ret;
            }
            T &top() {return this->at(0); }
        private:
            function<bool(T, T)> cmp;
    };

    Heap<int> h1, h2;
    MedianFinder() : h1{less<int>()}, h2{greater<int>()}{}
    
    void addNum(int num) {
        if(h1.size() == 0 || num <= h1.top()){
            h1.push(num);
        }else{
            h2.push(num);
        }
        if(h2.size() > h1.size()){
            h1.push(h2.pop());
        }
        if(h1.size() == h2.size() + 2){
            h2.push(h1.pop());
        }
        return;
    }
    
    double findMedian() {
        int n = h1.size() + h2.size();
        if(n %2 == 1){
            return h1.top();
        }
        return 1.0 * (h1.top() + h2.top()) / 2;
    }
};

264.丑数ii

class Solution {
public:
    template<typename T>
        class Heap : public vector<T>{
            public:
                template<typename Func_T>
                Heap(Func_T cmp) : cmp(cmp) {}
                void push(const T &a){
                    this->push_back(a);
                    push_heap(this->begin(), this->end(), cmp);
                    return ;
                }
                void pop(){
                    pop_heap(this->begin(), this->end(), cmp);
                    this->pop_back();
                    return ;
                }
                T &top() {return this->at(0); }
            private:
                function<bool(T, T)> cmp;
    };
    int nthUglyNumber(int n) {
        Heap<long long> h{greater<long long>()};
        long long ans = 0;
        h.push(1);
        while(n--){
            ans = h.top();
            h.pop();
            if(ans % 5 == 0){
                h.push(ans * 5);
            }else if(ans % 3 == 0){
                h.push(ans * 5);
                h.push(ans * 3);
            }else{
                h.push(ans * 5);
                h.push(ans * 3);
                h.push(ans * 2);
            }
        }
        return ans;    
    }
};

1753.移除石子的最大得分

class Solution {
public:
    int maximumScore(int a, int b, int c) {
        if (a > b) swap(a, b);
        if (a > c) swap(a, c);
        if (b > c) swap(b, c);
        int ans = 0;
        // step1
        int cnt1 = min(c - b, a);
        a -= cnt1;
        c -= cnt1;
        ans += cnt1;

        // step2
        if(a != 0){
            if(a % 2 == 1) a -= 1;
            b -= a / 2;
            c -= b / 2;
            ans += a;
        }

        // step3
        ans += b;
        return ans;
    }
};
欢欢学编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入理解堆与优先队列
⚡
01-31 1952
详解堆、堆排序与优先队列的概念
堆(heap)与优先队列（priority queue）
weixin_52575498的博客
03-25 3651
一、堆 1.堆定义： 如果这棵完全二叉树的任意结点的关键字小于或等于其左孩子和右孩子的关键字，则称之为小堆
优先队列和堆
数据工匠记
08-03 996
什么是优先队列？ 听这个名字就能知道，优先队列也是一种队列，只不过不同的是，优先队列的出队顺序是按照优先级来的；在有些情况下，可能需要找到元素集合中的最小或者最大元素，可以利用优先队列ADT（Abstract Data Type）来完成操作，优先队列ADT是一种数据结构，它支持插入和删除最小值操作（返回并删除最小元素）或删除最大值操作（返回并删除最大元素）； 这些操作等价于队列的enQueue和deQueue操作，区别在于，对于优先队列，元素进入队列的顺序可能与其被操作的顺序不同，作业调度是优先队列的一个应
堆(优先队列)
freeline的博客
03-15 1439
最大堆、最小堆的创建、删除、插入；堆排序
堆排序&优先队列
qq_40804920的博客
05-08 225
1、堆 （二叉）堆是一个数组，它可以被近似看成是一颗完全二叉树。树上的每一个结点都对应数组的一个元素。除了最底层，该树是完全充满的，该树在数组中是从左向右填充的。表示堆的数组A通常包括两个属性：数组长度A.length和堆的元素个数A.heapSize。给定一个结点的下标i，可以知道它的父结点、左孩子和右孩子的下标分别为i/2、2i和2i+1。 ...
底层实现数据结构：堆 Heap、优先队列
ChanYipFan的博客
04-14 453
//import jdk.internal.org.objectweb.asm.tree.IincInsnNode; public class MaxHeap<E extends Comparable<E>> { private Array<E> data; //构造函数 public MaxHeap(int capacity) { ...
堆排序和优先队列
laugh哥的博客
07-01 468
三种堆排序
堆与优先队列
qq_26760433的博客
11-21 381
1.堆的性质 （1）完全二叉树的层次序列，可以用数组表示 （2）堆中储存的数是局部有序的，堆不唯一 PS：节点的值与其孩子的值之间存在限制，任何一个节点与其兄弟之间都没有直接的限制。 （3）从逻辑角度看，堆实际上是一种树形结构 （4）堆是一种经过排序的完全二叉树，其中任一非终端节点的数据值均不大于（或不小于）其左子节点和右子节点的值。 2.堆和优先队列的关系 堆可以用于实现优先队列 3.堆的实现 ...
【C++】大根堆（优先队列 priority_queue）与 小根堆
m0_60641871的博客
06-29 2273
而在这个例子中，我们使用了STL自带的小根堆，因此需要将。是指底层容器的类型，而。是指比较函数对象的类型。
Heap —— Priority Queue 【堆 / 优先队列】
DarkAndGrey的博客
02-05 1742
前言 - 为堆的学习做准备 二叉树的顺序存储 前面所讲的二叉树，什么孩子表示法呀，还有 孩子双亲表示法啊，都是链式存储。 而现在讲的是：顺序存储一棵二叉树。   存储方式 使用数组保存二叉树结构，方式即将二叉树用层序遍历的方式放入数组中。 一般只适合表示完全二叉树，因为 非完全二叉树会有空间的浪费。【也就是说：如果使用顺序存储来存储一棵二叉树，那么，最好是完全二叉树，这样就不会有太多的空间被浪费】 这种方式的主要用法就是堆的表示。   下标关系 已知双亲（parent）的下标，则：
python 堆和优先队列的使用详解
12-31
这一点与C++中heap一系列的算法类似，底层是通过堆vector的维护获取堆的性质。 关于二叉树 二叉树的特点： 二叉树是一种存储数据元素的汇集数据结构。 二叉树最重要的性质就是树的高度和树中可以容纳的最大...
python实现最大优先队列
12-31
说明：为了增强可复用性，设计了两个类，Heap类和PriorityQ类，其中PriorityQ类继承Heap类，从而达到基于最大堆实现最大优先队列。 #! /usr/bin/env python #coding=utf-8 class Heap(object): #求给定下标i的父...
小大根交替堆实现双端优先队列
10-28
本项目采用小大根交替堆来实现双端优先队列，这在处理学生成绩查询等场景中具有实际应用价值。下面我们将详细探讨小大根交替堆及其在双端优先队列中的实现。 首先，让我们了解小大根交替堆的概念。小大根交替堆是一...
优先队列（Priority Queue）是一种特殊类型的队列
04-12
在实际实现中，优先队列通常使用堆（Heap）作为底层数据结构。堆是一种完全二叉树，满足堆性质：父节点的键值总是大于或等于（最小优先队列）或小于或等于（最大优先队列）其子节点的键值。这样可以确保根节点始终是...
c语言（7.23）
fhgfyrsg的博客
07-23 582
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 339
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 758
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 343
对于二分搜索的理论与实现的知识点学习。
数据结构：逻辑结构与物理结构
最新发布
Weiki的博客
07-24 957
数据结构：逻辑结构与物理结构
二叉堆与优先队列 python
09-17
在Python中，可以使用 heapq 模块来实现二叉堆和优先队列。下面是一个示例代码： ```python import heapq # 创建一个空的列表作为堆 heap = [] # 向堆中插入元素 heapq.heappush(heap, 5) heapq.heappush(heap, 2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值