优先级队列(Priority Queue)

最新推荐文章于 2024-05-01 22:41:01 发布
最新推荐文章于 2024-05-01 22:41:01 发布
阅读量2.9w 收藏 79
点赞数 9
分类专栏： C++数据结构 文章标签： 数据结构 队列 优先级队列 最小优先级队列 最大优先级队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cainv89/article/details/51588920
版权

优先级队列(Priority Queue)

注：队列是一种特征为FIFO的数据结构，每次从队列中取出的是最早加入队列中的元素。但是，许多应用需要另一种队列，每次从队列中取出的应是具有最高优先权的元素，这种队列就是优先级队列(Priority Queue)，也称为优先权队列。

1. 优先级队列的概念

1.1 优先级队列的定义
  • 优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。
1.2 优先级队列的特点
  • 优先级队列是0个或多个元素的集合，每个元素都有一个优先权或值。
  • 当给每个元素分配一个数字来标记其优先级时，可设较小的数字具有较高的优先级，这样更方便地在一个集合中访问优先级最高的元素，并对其进行查找和删除操作。
  • 对优先级队列，执行的操作主要有：(1)查找，(2)插入，(3)删除。
  • 在最小优先级队列(min Priority Queue)中，查找操作用来搜索优先权最小的元素，删除操作用来删除该元素。
  • 在最大优先级队列(max Priority Queue)中，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素。
  • 插入操作均只是简单地把一个新的元素加入到队列中。
  • 注：每个元素的优先级根据问题的要求而定。当从优先级队列中删除一个元素时，可能出现多个元素具有相同的优先权。在这种情况下，把这些具有相同优先权的元素视为一个先来先服务的队列，按他们的入队顺序进行先后处理。

2. 最小优先级队列的实现——基于一维数组的存储表示

2.1 最小优先级队列的类定义及其操作的实现

  • 文件：PriorityQueue.h

    
#ifndef PRIORITY_QUEUE_H_


#define PRIORITY_QUEUE_H_



#include <iostream>


#include <string>


#include <strstream>


using namespace std;

const int defaultSize = 50;

template <class T>
class PriorityQueue
{
public:
    PriorityQueue(int sz = defaultSize);        //构造函数
    ~PriorityQueue();                           //析构函数
public:
    bool getHead(T& x) const;       //读取队头(具最小优先权)的值
    bool Insert(const T& x);        //将新元素x插入到队尾
    bool RemoveMin(T& x);           //将队头元素删除       
    bool IsEmpty() const;           //判断队列是否为空
    bool IsFull() const;            //判断队列是否为满
    void MakeEmpty();               //置优先级队列为空
    int getSize() const;            //求优先级队列中元素个数
public:
    template <class T>
    friend ostream& operator<<(ostream& os, const PriorityQueue<T>& q); //输出队列元素的重载操作<<
private:
    void adjust();                  //队列调整
private:
    T *pqelements;  //存放队列元素的队列数组
    int maxSize;    //队列最大可容纳元素个数
    int count;      //当前元素个数(长度)
};

//构造函数
template <class T>
PriorityQueue<T>::PriorityQueue(int sz)
{
    cout << "$ 执行构造函数" << endl;
    if (sz >= 0)
    {
        maxSize = sz;           
        count = 0;      
        pqelements = new T[maxSize];
    }
}                       

//析构函数
template <class T>
PriorityQueue<T>::~PriorityQueue()
{
    cout << "$ 执行析构函数" << endl;
    delete[] pqelements;
    pqelements = NULL;
}   


//读取队头(具最小优先权)的值
template <class T>
bool PriorityQueue<T>::getHead(T& x) const
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = pqelements[0];
    return true;
}

//将新元素x插入到队尾
template <class T>
bool PriorityQueue<T>::Insert(const T& x)
{
    if (true == IsFull())
    {
        return false;
    }
    pqelements[count++] = x;
    adjust();   //按优先权进行调整
    return true;
}

//将队头元素删除
template <class T>
bool PriorityQueue<T>::RemoveMin(T& x)
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = pqelements[0];
    for (int i = 1; i < count; i++)
    {
        pqelements[i - 1] = pqelements[i];
    }
    count--;
    return true;
}

//判断队列是否为空
template <class T>
bool PriorityQueue<T>::IsEmpty() const
{
    return (0 == count) ? true : false;
}

//判断队列是否为满
template <class T>
bool PriorityQueue<T>::IsFull() const
{
    return (maxSize == count) ? true : false;
}

//置优先级队列为空
template <class T>
void PriorityQueue<T>::MakeEmpty()
{
    delete[] pqelements;
    count = 0;
    pqelements = new T[maxSize];
}

//求优先级队列中元素个数
template <class T>
int PriorityQueue<T>::getSize() const
{
    return count;
}

//输出队列元素的重载操作<<
template <class T>
ostream& operator<<(ostream& os, const PriorityQueue<T>& q)
{
    for (int i = 0; i < q.count; i++)
    {
        os << "[" << i << "]" << " : " << q.pqelements[i] << endl;
    }
    return os;
}

//队列调整
template <class T>
void PriorityQueue<T>::adjust()
{
    int i = 0;
    T temp = pqelements[count - 1];
    for (i = count - 2; i >= 0; i--)
    {
        if (pqelements[i] <= temp)
        {
            break;
        }
        pqelements[i + 1] = pqelements[i];
    }
    pqelements[i + 1] = temp;
}


#endif /* PRIORITY_QUEUE_H_ */
2.2 主函数(main函数)的实现

  • 文件：main.cpp

    
#include "PriorityQueue.h"



#define EXIT 0              //退出


#define GETHEAD 1           //读取队头(具最小优先权)的值


#define INSERT 2            //将新元素x插入到队尾


#define REMOVEMIN    3      //将队头元素删除


#define ISEMPTY  4          //判断队列是否为空


#define ISFULL 5            //判断队列是否为满


#define MAKEEMPTY 6         //置优先级队列为空


#define GETSIZE 7           //求优先级队列中元素个数


#define OPERATOR_OSTREAM 8  //输出队列元素的重载操作<<


void print_description()
{
    cout << "------------------------------>优先级队列<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 读取队头(具最小优先权)的值" << endl;
    cout << "#2： 将新元素x插入到队尾" << endl;
    cout << "#3： 将队头元素删除" << endl;
    cout << "#4： 判断队列是否为空" << endl;
    cout << "#5： 判断队列是否为满" << endl;
    cout << "#6： 置优先级队列为空" << endl;
    cout << "#7： 求优先级队列中元素个数" << endl;
    cout << "#8： 输出队列元素的重载操作<<" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//判断输入的字符串每个字符是否都是数值0~9
bool IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < '0') || (s_num[i] > '9'))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return StrToTtype<T>(s_data);
}

//输入数组的最大长度
template <class T>
int get_maxsize()
{
    cout << "> 请输入数组的最大长度，maxsize = ";
    string s_maxsize;
    cin >> s_maxsize;
    while (false == IsNumber(s_maxsize))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_maxsize;
    }
    return atoi(s_maxsize.c_str());
}

//构造优先级队列
template <class T>
PriorityQueue<T>* construct_priorityqueue()
{
    cout << "\n==> 创建优先级队列" << endl;
    int n_maxsize = get_maxsize<T>();
    PriorityQueue<T> *priorityQueue = new PriorityQueue<T>(n_maxsize);
    return priorityQueue;
}

//析构优先级队列
template <class T>
void destory_priorityqueue(PriorityQueue<T>* priorityQueue)
{
    cout << "\n==> 释放优先级队列在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete priorityQueue;
    priorityQueue = NULL;
}

//读取队头(具最小优先权)的值
template <class T>
void gethead(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行读取队头(具最小优先权)的值函数" << endl;
    T data;
    if (false == priorityQueue->getHead(data))
    {
        cout << "* 读取队头元素失败" << endl;
        return;
    }
    cout << "* 读取队头元素成功，data = " << data << endl;
}

//将新元素x插入到队尾
template <class T>              
void insert(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行将新元素x插入到队尾函数" << endl;
    T data = get_data<T>();
    if (false == priorityQueue->Insert(data))
    {
        cout << "* 入队失败" << endl;
        return;
    }
    cout << "* 入队成功，data = " << data << endl;
}

//将队头元素删除
template <class T>  
void removemin(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行将队头元素删除函数" << endl;
    T data;
    if (false == priorityQueue->RemoveMin(data))
    {
        cout << "* 出队失败" << endl;
        return;
    }
    cout << "* 出队成功，data = " << data << endl;
}

//判断队列是否为空
template <class T>  
void isempty(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行判断队列是否为空函数，IsEmpty = " << priorityQueue->IsEmpty() << endl;
}

//判断队列是否为满
template <class T>  
void isfull(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行判断队列是否为满函数，IsFull = " << priorityQueue->IsFull() << endl;
}

//置优先级队列为空
template <class T>
void makeempty(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行置优先级队列为空函数" << endl;
    priorityQueue->MakeEmpty();
}

//求优先级队列中元素个数
template <class T>  
void getsize(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行求优先级队列中元素个数函数，Size = " << priorityQueue->getSize() << endl;
}

//输出队列元素的重载操作<<
template <class T>
void operator_ostream(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行输出队列元素的重载操作<<函数" << endl;
    cout << *priorityQueue;//或operator<<(cout, *priorityQueue);
}

//优先级队列操作选择
template <class T>
void select_operation(PriorityQueue<T>* priorityQueue)
{
    if (NULL == priorityQueue)
    {
        cout << "* 没有构造优先级队列，请先构造优先级队列。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case GETHEAD://读取队头(具最小优先权)的值
            {
                gethead(priorityQueue);
                break;
            }
            case INSERT://将新元素x插入到队尾
            {
                insert(priorityQueue);
                break;
            }
            case REMOVEMIN://将队头元素删除
            {
                removemin(priorityQueue);
                break;
            }
            case ISEMPTY://判断队列是否为空
            {
                isempty(priorityQueue);
                break;
            }
            case ISFULL://判断队列是否为满
            {
                isfull(priorityQueue);
                break;
            }
            case MAKEEMPTY://置优先级队列为空
            {
                makeempty(priorityQueue);
                break;
            }
            case GETSIZE://求优先级队列中元素个数
            {
                getsize(priorityQueue);
                break;
            }
            case OPERATOR_OSTREAM://输出队列元素的重载操作<<
            {
                operator_ostream(priorityQueue);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    PriorityQueue<int> *priorityQueue = construct_priorityqueue<int>();
    select_operation(priorityQueue);
    destory_priorityqueue(priorityQueue);
    system("pause");
    return 0;
}

3. 最小优先级队列的实现——基于单链表的存储表示

3.1 最小优先级队列的类定义及其操作的实现

  • 文件：PriorityQueue.h

    
#ifndef PRIORITY_QUEUE_H_


#define PRIORITY_QUEUE_H_



#include <iostream>


#include <string>


#include <strstream>


using namespace std;

template <class T>
struct LinkNode         //链表结点类的定义
{
    T data;             //数据域
    LinkNode<T> *link;  //指针域——后继指针
    //仅初始化指针成员的构造函数
    LinkNode(LinkNode<T>* ptr = NULL){ link = ptr; }
    //初始化数据与指针成员的构造函数
    LinkNode(const T& value, LinkNode<T>* ptr = NULL){ data = value; link = ptr; }
};

template <class T>
class PriorityQueue
{
public:
    PriorityQueue();                //构造函数
    ~PriorityQueue();               //析构函数
public:
    bool getHead(T& x) const;       //读取队头(具最小优先权)的值
    bool Insert(const T& x);        //将新元素x插入到队尾
    bool RemoveMin(T& x);           //将队头元素删除   
    bool IsEmpty() const;           //判断队列是否为空
    bool IsFull() const;            //判断队列是否为满
    void MakeEmpty();               //置优先级队列为空
    int getSize() const;            //求优先级队列中元素个数
public:
    template <class T>
    friend ostream& operator<<(ostream& os, const PriorityQueue<T>& q); //输出队列中元素的重载操作<<
private:
    void adjust(LinkNode<T> *newNode);  //队列调整
private:
    LinkNode<T> *front; //队头指针，即链头指针
};

//构造函数
template <class T>
PriorityQueue<T>::PriorityQueue()
: front(NULL)
{
    cout << "$ 执行构造函数" << endl;
}                       

//析构函数
template <class T>
PriorityQueue<T>::~PriorityQueue()
{
    cout << "$ 执行析构函数" << endl;
    MakeEmpty();
}   

//读取队头(具最小优先权)的值
template <class T>
bool PriorityQueue<T>::getHead(T& x) const
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = front->data;
    return true;
}

//将新元素x插入到队尾
template <class T>
bool PriorityQueue<T>::Insert(const T& x)
{
    LinkNode<T> *newNode = new LinkNode<T>(x);
    if (NULL == newNode)
    {
        return false;
    }

    if (NULL == front)
    {
        front = newNode;
        return true;
    }
    adjust(newNode);
    return true;
}

//将队头元素删除
template <class T>
bool PriorityQueue<T>::RemoveMin(T& x)
{
    if (true == IsEmpty())
    {
        return false;
    }
    LinkNode<T> *curNode = front;
    front = front->link;
    x = curNode->data;
    delete curNode;
    return true;
}

//判断队列是否为空
template <class T>
bool PriorityQueue<T>::IsEmpty() const
{
    return (NULL == front) ? true : false;
}

//判断队列是否为满
template <class T>
bool PriorityQueue<T>::IsFull() const
{
    return false;
}

//置优先级队列为空
template <class T>
void PriorityQueue<T>::MakeEmpty()
{
    LinkNode<T> *curNode = NULL;
    while (NULL != front)           //当链表不为空时，删去链表中所有结点
    {
        curNode = front;            //保存被删结点
        front = curNode->link;      //被删结点的下一个结点成为头结点
        delete curNode;             //从链表上摘下被删结点
    }
}

//求优先级队列中元素个数
template <class T>
int PriorityQueue<T>::getSize() const
{
    int count = 0;
    LinkNode<T> *curNode = front;
    while (NULL != curNode)
    {
        curNode = curNode->link;
        count++;
    }
    return count;
}

//输出队列中元素的重载操作<<
template <class T>
ostream& operator<<(ostream& os, const PriorityQueue<T>& q)
{
    int i = 0;
    LinkNode<T> *curNode = q.front;
    while (NULL != curNode)
    {
        os << "[" << i++ << "]" << " : " << curNode->data << endl;
        curNode = curNode->link;
    }
    return os;
}

//队列调整
template <class T>
void PriorityQueue<T>::adjust(LinkNode<T> *newNode)
{
    LinkNode<T> *preNode = NULL;
    LinkNode<T> *curNode = front;
    while (NULL != curNode)
    {
        if (curNode->data > newNode->data)
        {
            break;
        }
        preNode = curNode;
        curNode = curNode->link;
    }

    if (preNode == NULL)
    {
        newNode->link = curNode;
        front = newNode;
    }
    else
    {
        preNode->link = newNode;
        newNode->link = curNode;
    }
}


#endif /* PRIORITY_QUEUE_H_ */
3.2 主函数(main函数)的实现

  • 文件：main.cpp

    
#include "PriorityQueue.h"



#define EXIT 0              //退出


#define GETHEAD 1           //读取队头(具最小优先权)的值


#define INSERT 2            //将新元素x插入到队尾


#define REMOVEMIN    3      //将队头元素删除


#define ISEMPTY  4          //判断队列是否为空


#define ISFULL 5            //判断队列是否为满


#define MAKEEMPTY 6         //置优先级队列为空


#define GETSIZE 7           //求优先级队列中元素个数


#define OPERATOR_OSTREAM 8  //输出队列元素的重载操作<<


void print_description()
{
    cout << "------------------------------>优先级队列<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 读取队头(具最小优先权)的值" << endl;
    cout << "#2： 将新元素x插入到队尾" << endl;
    cout << "#3： 将队头元素删除" << endl;
    cout << "#4： 判断队列是否为空" << endl;
    cout << "#5： 判断队列是否为满" << endl;
    cout << "#6： 置优先级队列为空" << endl;
    cout << "#7： 求优先级队列中元素个数" << endl;
    cout << "#8： 输出队列元素的重载操作<<" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//判断输入的字符串每个字符是否都是数值0~9
bool IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < '0') || (s_num[i] > '9'))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return StrToTtype<T>(s_data);
}

//构造优先级队列
template <class T>
PriorityQueue<T>* construct_priorityqueue()
{
    cout << "\n==> 创建优先级队列" << endl;
    PriorityQueue<T> *priorityQueue = new PriorityQueue<T>;
    return priorityQueue;
}

//析构优先级队列
template <class T>
void destory_priorityqueue(PriorityQueue<T>* priorityQueue)
{
    cout << "\n==> 释放优先级队列在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete priorityQueue;
    priorityQueue = NULL;
}

//读取队头(具最小优先权)的值
template <class T>
void gethead(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行读取队头(具最小优先权)的值函数" << endl;
    T data;
    if (false == priorityQueue->getHead(data))
    {
        cout << "* 读取队头元素失败" << endl;
        return;
    }
    cout << "* 读取队头元素成功，data = " << data << endl;
}

//将新元素x插入到队尾
template <class T>
void insert(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行将新元素x插入到队尾函数" << endl;
    T data = get_data<T>();
    if (false == priorityQueue->Insert(data))
    {
        cout << "* 入队失败" << endl;
        return;
    }
    cout << "* 入队成功，data = " << data << endl;
}

//将队头元素删除
template <class T>
void removemin(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行将队头元素删除函数" << endl;
    T data;
    if (false == priorityQueue->RemoveMin(data))
    {
        cout << "* 出队失败" << endl;
        return;
    }
    cout << "* 出队成功，data = " << data << endl;
}

//判断队列是否为空
template <class T>
void isempty(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行判断队列是否为空函数，IsEmpty = " << priorityQueue->IsEmpty() << endl;
}

//判断队列是否为满
template <class T>
void isfull(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行判断队列是否为满函数，IsFull = " << priorityQueue->IsFull() << endl;
}

//置优先级队列为空
template <class T>
void makeempty(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行置优先级队列为空函数" << endl;
    priorityQueue->MakeEmpty();
}

//求优先级队列中元素个数
template <class T>
void getsize(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行求优先级队列中元素个数函数，Size = " << priorityQueue->getSize() << endl;
}

//输出队列元素的重载操作<<
template <class T>
void operator_ostream(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行输出队列元素的重载操作<<函数" << endl;
    cout << *priorityQueue;//或operator<<(cout, *priorityQueue);
}

//优先级队列操作选择
template <class T>
void select_operation(PriorityQueue<T>* priorityQueue)
{
    if (NULL == priorityQueue)
    {
        cout << "* 没有构造优先级队列，请先构造优先级队列。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case GETHEAD://读取队头(具最小优先权)的值
            {
                gethead(priorityQueue);
                break;
            }
            case INSERT://将新元素x插入到队尾
            {
                insert(priorityQueue);
                break;
            }
            case REMOVEMIN://将队头元素删除
            {
                removemin(priorityQueue);
                break;
            }
            case ISEMPTY://判断队列是否为空
            {
                isempty(priorityQueue);
                break;
            }
            case ISFULL://判断队列是否为满
            {
                isfull(priorityQueue);
                break;
            }
            case MAKEEMPTY://置优先级队列为空
            {
                makeempty(priorityQueue);
                break;
            }
            case GETSIZE://求优先级队列中元素个数
            {
                getsize(priorityQueue);
                break;
            }
            case OPERATOR_OSTREAM://输出队列元素的重载操作<<
            {
                operator_ostream(priorityQueue);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    PriorityQueue<int> *priorityQueue = construct_priorityqueue<int>();
    select_operation(priorityQueue);
    destory_priorityqueue(priorityQueue);
    system("pause");
    return 0;
}

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第三章
[2] 百度搜索关键字：优先级队列

Cainv89
关注
  • 9
    点赞
  • 踩
  • 79
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
优先级队列 priority queue
06-21
优先级队列的实现，包括堆的实现，最大堆的生成
priority queue优先级队列
01-03
算法中优先级队列问题...用堆排序的算法来做的例子
priority_queue 的常见用法详解
weixin_52914088的博客
08-15 2万+
1，priority_queue 又称为优先队列，其底层是用堆来进行实现的。在优先队列中，队首元素一定是当前队列中优先级最高的那一个。 当然，可以在任何时候往优先队列里面加入元素，而优先队列底层的数据结构堆（heap）会随时调整结构，使得每次的队首元素都是优先级最高的，话不多说让我们一起来了解一下吧。 2.priority_queue 的定义 要使用优先队列，应先添加头文件 #include<queue> ,并在头文件下面加上“using namespace std;”。 其定义..
【C++】priority_queue(优先级队列)
心之王者的博客
11-25 714
本文简要介绍优先级队列、容器适配器和仿函数的概念
C++ 优先级队列priority_queue
最新发布
qq_51216031的博客
05-01 620
底层使用的是堆实现，默认为大堆。
数据结构（C语言描述）优先队列
qq_740785701的博客
03-30 3202
1 优先队列的定义 优先队列是一个以集合为基础的抽象数据类型。 优先队列中的每一个元素都有一个优先级。 定义在优先队列上的基本运算如下。 Min(H): 返回优先队列H中具有最下优先级的元素。 Insert(x,H): 将元素x插入优先队列H。 DeleteMin(H): 删除并返回优先队列H中具有最小优先级的元素。 在优先队列中，是按照每个对象的优先级顺序进行的。 2 优先队列的简单实现 所有实现字典的方法都可用于实现优先队列。优先队列中元素的优先级可以看成字典中元素的线性序值。 用有序链表实现优先队列，
数据结构——优先队列c++详解
m0_54615144的博客
11-12 3723
优先队列
Java笔记：PrioriyQueue解决TopK问题(Comparator)
长不大的大灰狼
02-20 532
优先级队列——PriorityQueue 在大量数据中找前4个最大的数： 1）首先将待排序的前4个元素进行建堆（小堆）。 2）遍历剩下的元素，如果比堆顶元素小，那么就将堆顶元素出堆，当前元素入堆。 注意： 如果找最小的4个元素，则需要建立大堆。 PriorityQueue默认建的是小堆，要想改变调整顺序，调整为大堆，那么就需要传入一个比较器。 java代码实现： public static I...
C++ 中”priority_queue” 优先级队列实例详解
12-31
C++ 中”priority_queue” 优先级队列实例详解 1. 简介 标准库队列使用了先进先出(FIFO)的存储和检索策略. 进入队列的对象被放置在尾部, 下一个被取出的元素则取自队列的首部. 标准库提供了两种风格的队列: FIFO ...
优先队列(priority_queue)的C语言实现代码
09-04
1. `priority_queue_new`：创建一个新的优先队列，根据指定的优先级策略初始化队列。 2. `priority_queue_free`：释放优先队列占用的所有资源，包括队列内的所有元素。 3. `priority_queue_top`：获取但不移除队列...
prioqueue：ES6的优先级队列
02-05
优先级队列是一种抽象队列类型，类似于常规队列或堆栈数据结构，但是其中每个项目都具有与其关联的priority 。 在优先级队列中，优先级高的项先于优先级低的项。 为了提高性能，Prioqueue优先级队列使用数组实现的二...
优先队列&&队列
stven_king的专栏
12-18 474
优先队列用法 转载：http://www.cppblog.com/shyli/archive/2007/04/06/21366.html 在优先队列中，优先级高的元素先出队列。 标准库默认使用元素类型的 优先队列的第一种用法，也是最常用的用法： 基本操作： empty() 如果队列为空返回真 pop() 删除对顶元素 push() 加入一个元素 size() 返回优先队列中拥有的元素个数 top
一文带你掌握 优先级队列
@初阶牛的博客
10-02 255
本文通过底层实现优先级队列的部分接口,构建优先级队列的步骤图等详细讲解的方式,使读者对优先级队列有深刻的理解. 利用优先级队列排序,排升序,降序..
优先级队列
qq_2192330908的博客
11-17 408
优先级队列（priority queue） 是0个或多个元素的集合，每个元素都有一个优先权，对优先级队列执行的操作有（1）入队列（2）出队列 （3）取队首元素，一般情况下，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素 。对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。优先级队列的实现方式有很多，但常见的是使用堆来构建。 1、入队列操作步骤： 1）首先按尾插方式放入数...
priority_queue的常见用法详解
辉小歌的博客
03-25 5836
目录前言priorithy_queue的定义priority_queue容器内元素的访问priority_queue常用函数priority_queue内元素优先级的设置priority_queue的常见用途 前言 priority_queue又称为优先队列，其底层是用堆来进行实现的。在优先队列中，队首元素一定是当前队列中优先级最高的那一个。 例如在队列有如下元素，且定义好了优先级: 桃子(优先级3) 梨子(优先级4) 苹果(优先级1) 那么出队的顺序为: 梨子(4)->桃子(3)->苹果(1
优先级队列（priority_queue）用法详解
qq_42978418的博客
08-03 576
优先级队列
C++ 优先队列 priority_queue 的基本使用方法【定义优先级】
Hi_jiaxinwei的博客
04-14 5961
转自： #include #include using namespace std; priority_queue big; //大根堆 priority_queue,greater > small; //小根堆，最后的两个“>”之间要有空格，vector不用单另开头文件。 C++中优先队列（priority queue 常用来代替堆，每次直接加入新数
优先队列的排序写法
hahahaha
10-28 6189
1.普通方法： priority_queuequ; 对入队的元素默认按照从大到小排序。 2.自定义优先级： struct cmp{   bool operator()(int x,int y) {     return x>y;   //从小到大排序。即x小的优先级高。 } }; priority_queue,cmp>qu; 3.对结构体进行重载操作符： struc
【原创】优先队列 priority_queue 详解
热门推荐
致上
04-25 13万+
c++ 的 stl 里的 优先队列 priority_queue 的声明和基本操作
java创建优先权队列
10-12
可以使用Java中的PriorityQueue类来创建优先队列。PriorityQueue是一个基于优先级堆的无界优先队列，它的元素按照自然顺序进行排序或者根据构造函数中提供的Comparator进行排序。以下是一个示例代码： ``` import java.util.PriorityQueue; public class PriorityQueueExample { public static void main(String[] args) { // 创建一个优先队列 PriorityQueue<Integer> pq = new PriorityQueue<>(); // 添加元素到队列中 pq.add(5); pq.add(1); pq.add(10); pq.add(3); // 输出队列中的元素 while (!pq.isEmpty()) { System.out.print(pq.poll() + " "); } } } ``` 输出结果为：1 3 5 10

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值