精华内容
下载资源
问答
  • 使用priority_queue容器适配器所有操作函数,实现最大优先队列最小值优先队列#include #include #include #include #include #include <functional>using namespace std; void main() {

    使用priority_queue容器适配器所有操作函数,实现最大值优先队列和最小值优先队列


    最大值优先队列

    #include <iostream>
    using namespace std;
    int main()
    {
    	int a[] = { 1,2,3,4,5,6,7,8,9,10 };
    	priority_queue<int > pr(a, a + 9);//通过构造函数将a[0]~a[8]送入优先队列
    	pr.push(a[9]);//通过函数将a[9]送入优先队列
    	cout << "进队顺序:"; copy(a, a + 10, ostream_iterator<int>(cout, " "));cout << endl;
    
    	cout << "出队顺序:";
    	while (!pr.empty())
    	{
    		cout << pr.top() << " ";//获得优先队列队头元素
    		pr.pop();//删除队头元素
    	}
    	cout << endl;
    }
    
    进队顺序:5 7 4 2 1 3 6 9 0 8 
    出队顺序:9 8 7 6 5 4 3 2 1 0 
    

    最小值优先队列

    int main()
    {
    	int b[] = { 1,2,3,4,5,6,7,8,9,10 };
    	priority_queue<int, vector<int>, greater<int> > prb(b, b + 9);//通过构造函数将a[0]~a[8]送入优先队列
    	prb.push(b[9]);//通过函数将a[9]送入优先队列
    	cout << "进队顺序:"; copy(b, b + 10, ostream_iterator<int>(cout, " "));cout << endl;
    	cout << "出队顺序:";
    	while (!prb.empty())
    	{
    		cout << prb.top() << " ";//获得优先队列队头元素
    		prb.pop();//删除队头元素
    	}
    }
    
    进队顺序:5 7 4 2 1 3 6 9 0 8 
    出队顺序:0 1 2 3 4 5 6 7 8 9 
    
    展开全文
  • C++之priority_queue(最大值优先级队列、最小值优先队列) 文章目录C++之priority_queue(最大值优先级队列、最小值优先队列)前言一、优先级队列二、用法三、用法案例 前言 1、最大值优先级队列、最小值优先级队列 2...

    C++之priority_queue(最大值优先级队列、最小值优先队列)

    前言

    1、最大值优先级队列、最小值优先级队列
    2、优先级队列适配器 STL priority_queue
    

    一、优先级队列

    优先队列容器与队列一样,只能从队尾插入元素,从队首删除元素。但是它有一个特性,就是队列中最大的元素总是位于队首,所以出队时,并非按照先进先出的原则进行,而是将当前队列中最大的元素出队。这点类似于给队列里的元素进行了由大到小的顺序排序。元素的比较规则默认按元素值由大到小排序,可以重载“<”操作符来重新定义比较规则。

    优先级队列可以用向量(vector)或双向队列(deque)来实现(注意list container不能用来实现queue,因为list的迭代器不是任意存取iterator,而pop中用到堆排序时是要求randomaccess iterator 的!):
    priority_queue<vector, less > pq1;     // 使用递增less函数对象排序
    priority_queue<deque, greater > pq2;   // 使用递减greater函数对象排序
    默认情况下是最大值优先队列,也就是递增

    二、用法

    1、pq.empty();
    2、pq.size();
    3、pq.top();
    4、pq.pop();
    5、pq.push(item);
    

    三、用法案例

    void main()
    {
     priority_queue<int> p1;//默认情况下是最大值优先队列
     priority_queue<int,vector<int>,less<int>>  p2;//最大值优先队列
     priority_queue<int,vector<int>,greater<int>> p3;//最小值优先队列
    
     p1.push(33)l
     p1.push(11);
     p1.push(44);
     p1.push(22);
     while(p1.size()>0)
     {
    	cout<<p1.top()<<" ";//输出队头元素
     	p1.pop();//让队头元素出栈
     }
     结果: 44  33  22  11
     如果用p3完成上述操作的话
     结果: 11  22  33  44
    
    展开全文
  • 某些情况下,我们可能需要队列中最大值或者最小值,例如使用一个队列保存计算机的任务,一般情况下计算机的任务都是有优先级的,我们需要这些计算机的任务中找出优先级最高的任务先执行,执行完毕后就需要...

    优先队列(最小优先队列)

    前言

            普通的队列是一种先进先出的数据结构,元素在队列尾追加,而从队列头删除。在某些情况下,我们可能需要找出队列中的最大值或者最小值,例如使用一个队列保存计算机的任务,一般情况下计算机的任务都是有优先级的,我们需要在这些计算机的任务中找出优先级最高的任务先执行,执行完毕后就需要把这个任务从队列中移除。普通的队列要完成这样的功能,需要每次遍历队列中的所有元素,比较并找出最大值,效率不是很高,这个时候,我们就可以使用一种特殊的队列来完成这种需求,优先队列

    一、最小优先队列

            最大优先队列基于堆的数据结构来实现,可以很方便的删除最小值

    1、代码实现

    package tree;
    
    /**
     * 最小优先队列
     */
    public class MinPriorityQueue<T extends Comparable<T>> {
    
        private T[] items;
    
        private int n;
    
        public MinPriorityQueue(int capacity) {
            // 默认数组的0 索引位置不存放元素
            items = (T[]) new Comparable[capacity + 1];
            n = 0;
        }
    
        public int size() {
            return n;
        }
    
        /**
         * 向队列中插入元素
         *
         * @param t
         */
        public void add(T t) {
            // 插入到数组末尾
            items[++n] = t;
            // 元素上浮
            swim(n);
        }
    
        /**
         * 删除队列中的最小元素
         *
         * @return 返回删除最小的元素
         */
        public T deleteMin() {
            T min = items[1];
            items[1] = items[n];
            items[n] = null;
            n--;
            sink(1);
            return min;
        }
    
        /**
         * 元素下沉
         */
        private void sink(int k) {
            //条件:存在子节点
            while (2 * k <= n) {
                // 左子节点和右子节点中较小值值的索引值
                int biggerIndex = 0;
                // 存在右子节点,且右子节点较小,
                if (2 * k + 1 <= n && less(2 * k+1, 2 * k)) {
                    biggerIndex = 2 * k + 1;
                } else {
                    biggerIndex = 2 * k;
                }
                // 如果当前节点值大于 子节点中的较小值,交换值
                if (less(biggerIndex, k)) {
                    exch(biggerIndex, k);
                    k = biggerIndex;
                } else {
                    break;
                }
            }
        }
    
        /**
         * 元素上浮
         */
        private void swim(int k) {
            // 循环条件 存在父节点
            while (k / 2 >= 1) {
                // 如果当前节点小于父节点,交换值
                if (less(k, k / 2)) {
                    exch(k, k / 2);
                    k = k / 2;
                } else {
                    break;
                }
            }
        }
    
        /**
         * 判断索引i处值是否小于索引j处值
         *
         * @param i
         * @param j
         * @return
         */
        private boolean less(int i, int j) {
            return items[i].compareTo(items[j]) < 0;
        }
    
        /**
         * 交换元素
         *
         * @param i
         * @param j
         */
        private void exch(int i, int j) {
            T temp = items[i];
            items[i] = items[j];
            items[j] = temp;
        }
    }
    
    

    2、测试用例

    package tree;
    
    import org.junit.Test;
    
    import static org.junit.Assert.*;
    
    public class MinPriorityQueueTest {
    
        @Test
        public void deleteMin() {
    
            MinPriorityQueue<Integer> comparableMinPriorityQueue = new MinPriorityQueue<Integer>(10);
            comparableMinPriorityQueue.add(100);
            comparableMinPriorityQueue.add(99);
            comparableMinPriorityQueue.add(88);
            comparableMinPriorityQueue.add(77);
            comparableMinPriorityQueue.add(200);
            comparableMinPriorityQueue.add(250);
            comparableMinPriorityQueue.add(244);
            comparableMinPriorityQueue.add(311);
    
            int size = comparableMinPriorityQueue.size();
    
            for (int i = 0; i < size - 1; i++) {
                System.out.println(comparableMinPriorityQueue.deleteMin());
            }
        }
    }
    

    3、控制台输出

    77
    88
    99
    100
    200
    244
    250
    
    
    展开全文
  • 目录0 优先队列1 最大优先队列2 最小优先队列 0 优先队列 普通队列先进先出,队尾加,队头...按照功能需求分两种:1 最大优先队列:获取并删除队列最大的值;2 最小优先队列:获取并删除队列最小的值。 1 最大优

    0 优先队列

    1. 普通队列先进先出,队尾加,队头删;
    2. 某些情况下,我们需要找出队列中的最大值或最小值。比如使用一个队列保存计算机的任务,任务需要有优先级,我们需要找出优先级最高的任务先执行,执行完毕后将任务从队列删除。
    3. 普通队列完成任务,需要遍历队列所有元素,比较并找出最大值,效率低下;
    4. 这时可以使用一种特殊的队列来完成需求,即优先队列。
    5. 按照功能需求分两种:1 最大优先队列:获取并删除队列中最大的值;2 最小优先队列:获取并删除队列中最小的值。

    1 最大优先队列

    由于堆可以很方便地删除最大值,因此基于堆实现最大优先队列。

    Java实现:

    public class MaxPriorityQueue<T extends Comparable<T>> {
        //存储堆中的元素
        private T[] items;
        //记录堆中元素的个数
        private int N;
    
        public MaxPriorityQueue(int capacity) {
            this.items = (T[]) new Comparable[capacity+1];
            this.N = 0;
        }
    
        //获取队列中元素的个数
        public int size() {
            return N;
        }
    
        //判断队列是否为空
        public boolean isEmpty() {
            return N==0;
        }
    
        //往堆中插入一个元素
        public void insert(T t) {
            items[++N] = t;
            swim(N);
        }
    
        //删除堆中最大的元素,并返回这个最大元素
        public T delMax() {
            T max = items[1];
            exch(1,N);
            items[N] = null;
            N--;
            sink(1);
            return max;
        }
    
        //使用上浮算法,使索引k处的元素能在堆中处于一个正确的位置
        private void swim(int k) {
            while(k>1){
                if (less(k/2,k)){
                    exch(k/2,k);
                } else {
                    break;
                }
                k = k/2;
            }
        }
    
        //使用下沉算法,使索引k处的元素能在堆中处于一个正确的位置
        private void sink(int k) {
            while(2*k<=N){
                int max;
                if (2*k+1<=N){
                    if (less(2*k,2*k+1)){
                        max = 2*k+1;
                    }else{
                        max = 2*k;
                    }
                }else {
                    max = 2*k;
                }
                if (!less(k,max)){
                    break;
                }
                exch(k,max);
                k = max;
            }
        }
    
        //判断堆中索引i处的元素是否小于索引j处的元素
        private boolean less(int i, int j) {
            return items[i].compareTo(items[j])<0;
        }
    
        //交换堆中i索引和j索引处的值
        private void exch(int i, int j) {
            T tmp = items[i];
            items[i] = items[j];
            items[j] = tmp;
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            String[] arr = {"S","O","T","E","X","A","M","P","L","E"};
            MaxPriorityQueue<String> maxpq = new MaxPriorityQueue<>(20);
            for (String s: arr) {
                maxpq.insert(s);
            }
            System.out.println(maxpq.size());
            String del;
            while(!maxpq.isEmpty()) {
                del = maxpq.delMax();
                System.out.print(del + ",");
            }
        }
    }
    
    10
    X,T,S,P,O,M,L,E,E,A,
    

    2 最小优先队列

    最大优先队列基于堆的思想实现,堆中存放数据的数组满足如下两个特性:

    1. 最大元素放在数组的索引1处;
    2. 每个结点的数据总是大于等于它的两个子结点的数据。

    为了实现最小优先队列,我们可以用相反的思想实现最小堆,使堆中存放数据的数据满足如下两个特性:

    1. 最小的元素放在数组的索引1处;
    2. 每个结点的数据总是小于等于它的两个子结点的数据。

    Java代码实现:

    public class MinPriorityQueue<T extends Comparable<T>> {
        //存储堆中的元素
        private T[] items;
        //记录堆中元素的个数
        private int N;
    
        public MinPriorityQueue(int capacity) {
            this.items = (T[]) new Comparable[capacity+1];
            this.N=0;
        }
    
        //获取队列中元素的个数
        public int size() {
            return N;
        }
    
        //判断队列是否为空
        public boolean isEmpty() {
            return N == 0;
        }
    
        //往堆中插入一个元素
        public void insert(T t) {
            items[++N] = t;
            swim(N);
        }
    
        //删除堆中最小的元素,并返回这个最小元素
        public T delMin() {
            T min = items[1];
            exch(1,N);
            items[N] = null;
            N--;
            sink(1);
            return min;
        }
    
        //使用上浮算法,使索引k处的元素能在堆中处于一个正确的位置
        private void swim(int k) {
            //通过循环比较当前结点和其父结点的大小
            while(k>1){
                if (less(k,k/2)){
                    exch(k,k/2);
                } else {
                    break;
                }
                k = k/2;
            }
        }
    
        //使用下沉算法,使索引k处的元素能在堆中处于一个正确的位置
        private void sink(int k) {
            //通过循环比较当前结点和其子结点中的较小值
            while(2*k<=N){
                //1.找到子结点中的较小值
                int min;
                if (2*k+1<=N){
                    if (less(2*k, 2*k+1)){
                        min = 2*k;
                    }else{
                        min = 2*k+1;
                    }
                }else{
                    min = 2*k;
                }
                //2.判断当前结点和较小值的大小
                if (!less(min,k)){
                    break;
                }
                exch(k,min);
                k = min;
            }
        }
    
        //判断堆中索引i处的元素是否小于索引j处的元素
        private boolean less(int i, int j) {
            return items[i].compareTo(items[j])<0;
        }
    
        //交换堆中i索引和j索引处的值
        private void exch(int i, int j) {
            T tmp = items[i];
            items[i] = items[j];
            items[j] = tmp;
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            String[] arr = {"S","O","T","E","X","A","M","P","L","E"};
            MinPriorityQueue<String> minpq = new MinPriorityQueue<>(20);
            for (String s: arr) {
                minpq.insert(s);
            }
            System.out.println(minpq.size());
            String del;
            while(!minpq.isEmpty()) {
                del = minpq.delMin();
                System.out.print(del + ",");
            }
        }
    }
    
    10
    A,E,E,L,M,O,P,S,T,X,
    
    展开全文
  • 优先队列(最大优先队列)前言一、最大优先队列1、最大优先队列API设计2、代码3、测试用例4、输出结果 前言         普通的队列是一种先进先出的数据结构,元素队列尾...
  • 数据结构-优先队列(最大优先队列、最小优先队列、索引优先队列) 由于队列先进先出的特性,无法灵活按照优先级进行数据的获取。但是应用又有此类需求,例如计算机按照优先级进行的任务调度。 所以需要对于队列...
  • 某些情况下,我们可能需要队列中最大值或者最小值,例如使用一个队列保存计算机的任务,一般情况下,计算机的任务都是有优先级的,我们需要这些计算机的任务中找出优先级最高的任务先执行,执行完毕后就...
  • 在优先队列中,元素被赋予优先级。当访问元素时,具有最高优先级的元素最先删除。优先队列具有最高级先出 (first in, largest out)的行为特征。 首先要包含头文件#include, 他和queue不同的就在于我们可以自定义...
  • C++中优先队列priority_queue的基础用法

    千次阅读 多人点赞 2020-09-12 17:28:51
    学习优先队列之前先看个单词队列 queue, 这个单词的读法很多人都能独对吧,音标是 `/kjuː/` ,再看一个双端队列 deque,它的音标是 `/dek/`,应该有人读错了吧,反正我是没读对,刚开始看见一次错一次,现在还好了...
  • 【JAVA】每类各选一个后求最大最小值差值得最小值(Pro20210802)(优先级队列 / IndexTree题目:思路:代码(优先级队列):代码(IndexTree): 题目: Lin 打算自己住的村子里建 N 个不同的便利设施。每个便利...
  • c++ 优先级队列输出最小值

    千次阅读 2017-08-15 15:39:18
    库函数优先级队列(priority_queue)输出最小值 代码 本文地址: http://blog.csdn.NET/caroline_wendy 库函数优先级队列(priority_queue)的实现方式是堆(heap), 默认是输出最大值.最大堆 输出...
  • 某些情况下,我们可能需要队列中最大值或者最小值,例如使用一个队列保存计算机的任务,一般情况下计算机的任务都是有优先级的,我 们需要这些计算机的任务中找出优先级最高的任务先执行,执行完毕后就...
  • 优先队列及最小堆最大

    千次阅读 2015-06-20 16:30:08
    为什么优先队列里默认是堆(heap)实现,默认是优先级高的出队,定义结构体重载函数为什么要按照从小到大排序?原来是自己对优先队列还不太了解: 1 堆  1.1 简介 n个关键字序列Kl,K2,…,Kn称为(Heap),当...
  • 什么是优先队列

    万次阅读 多人点赞 2019-05-20 07:32:00
    来源:公众号【编程珠玑】 作者:守望先生 前言 我们之前已经介绍过《如何自己实现一个队列》,它们是先入先出的,...优先队列中的每个元素都有优先级,而优先级高(或者低)的将会先出队,而优先级相同的则...
  • 最大二叉堆的Java实现 : /** ... * @PriorityQueue 优先队列 * * @KeyMethod : * insert(enqueue) , deleteMax(extractMax,dequeue) * * @最大二叉堆实现核心算法(2-堆) : * 1. 向上过滤 : 用插入方法。
  • 优先队列(滑动窗口求最大值) 题目链接 题目要求我们求出长度为k的滑动窗口的最大值和最小值 如果是用暴力的求法的话时间复杂度为O(n×k)O(n\times k)O(n×k),这样就会导致超时。 所以我们就要优化方案,暴力的...
  • 算法实践,有的算法要求不停地插入或移除最大最小值。若用线性比较,则时间复杂度为O(n2n^2n2)。这时候,若用优先队列,则可有效降低时间复杂度。优先队列又称为堆。它的复杂度为O(logN). 当N比较大时,能够...
  • 优先队列概念引出堆的概念,堆的删除提到“向下过滤”思想。
  • //支持优先队列最大值和最小值删除,aType = 0是删除最小值 aType = 1是删除最大值 void STdeleteMinAndMax(int aType) {  STfilterData();   int ret = 0;   int i = 0;   int n = STcount();...
  • 优先队列 满足操作: 插入一个数值 取出最小的数值(获得数值,并且删除) 实现:堆(二叉搜索树) 堆 性质:二叉树,儿子的值一定不小于父亲的值。 初始堆 插入数值举例,向初始堆插入数值3时,首先堆的末尾...
  • greater参数对应最小堆,堆顶元素为最小值;less参数对应最大堆,堆顶元素为最大值。(反着记就行) 代码如下: #include &amp;lt;iostream&amp;gt; #include &amp;lt;queue&amp;gt; using ...
  • 我们每次要找到序列最小的两个数,而它们合并后序列的最小值同时会发生变化,需要我们重新维护,常见的想法就是每次合并后都重新排序,可想而知时间复杂度我们无法承受(然而事实是加上快读我们能非常极限的时限...
  • STL优先队列详解

    千次阅读 2015-05-03 10:11:15
    优先队列  优先队列是一种抽象数据类型(Abstract Date Type,ADT),行为和队列... STL的优先队列定义头文件和 (队列一样),用"priority_queuepq"来声明; 最基本的用法  定义:priority_queuepq;
  •  //否则队列的数量大于或者等于K,优先队列中的最小数字小于新的数据,优先队列中的顶堆要被移除,并且添加入新的数据进优先队列 pq.poll(); pq.offer(val); } } return pq.peek();//返回当前第K大的数 } }...
  • Java数据结构--树一、平衡树1.1 2-3 查找树1.1.1 2-3查找树的定义1.1.2 查找1.1.3 插入1.1.3.1 向2-结点插入新键1.1.3.2 向一棵只含有一个3-结点的树插入新键1.1.3.3 向一个父结点为2-结点的3-结点插入新键1.3...
  • 使用堆排序实现优先队列

    千次阅读 2019-07-12 11:55:59
    堆有序:数组,每个元素大于等于两个特定位置的元素。二叉树,每个父节点的值要大于等于两个子节点的值 完全二叉树:每个节点的子节点个数为2或0 二叉堆:是一组能用堆有序的完全二叉树排序的元素,并数组...
  • ref ...note 定义: priority_queue<int,vector,less> q;最大堆(默认为最大堆) priority_queue<int,vector,greater> q;最小堆 Priority queues are a type of c...
  • 建议读者先去下载《啊哈算法》看大概P182页的堆,什么是最小堆? ps:如果想进来学习什么是堆的童鞋们,你们不需要再继续往下面阅读啦,对你们有意义的是第一行哦~随后我将此本算法书会长传到csdn上哦~ 而已经...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,507
精华内容 7,002
关键字:

在最大优先队列中找最小值