C ++: la diferencia entre cola y prioridad_queue

Introducción de cola

Introducción de documento de cola

Traducción:

1. Una cola es un adaptador de contenedor diseñado para operar en un contexto FIFO (primero en entrar, primero en salir), donde los elementos se insertan desde un extremo del contenedor y se extraen del otro extremo.

2. La cola se implementa como un adaptador de contenedor, que encapsula una clase de contenedor específica como su clase de contenedor subyacente, y la cola proporciona un conjunto específico de funciones miembro para acceder a sus elementos. Los elementos entran en la cola desde el final del equipo y salen de la cola del jefe del equipo.

3. El contenedor subyacente puede ser una de las plantillas de clase de contenedor estándar u otras clases de contenedor especialmente diseñadas. El contenedor subyacente debe admitir al menos las siguientes operaciones:
   vacío: detecta si la cola está vacía
   Tamaño: devuelve el número de elementos válidos en el
   frente de la cola : devuelve la referencia del elemento principal
   atrás: devuelve la referencia del elemento de cola
   push_back: ingresa la cola al final de la cola
   pop_front : Deje la cola en la cabecera de la cola

4. Las clases de contenedor estándar eliminan y enumeran estos requisitos. De forma predeterminada, si no se especifica ninguna clase de contenedor para la creación de instancias de cola, se utiliza la eliminación de contenedor estándar.

Uso de la cola

Declaración de función	Descripción de la interfaz
cola()	Construir una cola vacía
vacío()	Compruebe si la cola está vacía, devuelva verdadero, de lo contrario devuelva falso
Talla()	Devuelve el número de elementos válidos en la cola.
frente()	Devuelve una referencia al elemento head
espalda()	Devuelve una referencia al elemento de cola
empujar()	Val elementos en la cola al final de la cola
popular()	Eliminar el elemento de cabecera de la cola

Introducción de priority_queue

Introducción al documento prioridad_queue

Traducción:

1. La cola prioritaria es un adaptador de contenedor. Según estrictos criterios de orden débil, su primer elemento es siempre el más grande de los elementos que contiene.

2. Este contexto es similar al del montón, donde los elementos se pueden insertar en cualquier momento, y solo se puede recuperar el elemento del montón más grande (el elemento superior en la cola de prioridad).

3. La cola prioritaria se implementa como un adaptador de contenedor, que encapsula una clase de contenedor específica como su clase de contenedor subyacente, y la cola proporciona un conjunto específico de funciones miembro para acceder a sus elementos. Los elementos salen de la "cola" de un contenedor particular, que se llama la parte superior de la cola de prioridad.

4. El contenedor subyacente puede ser cualquier plantilla de clase de contenedor estándar, o puede ser una clase de contenedor de otros diseños específicos. El contenedor debe ser accesible a través de un iterador de acceso aleatorio, y admite las siguientes operaciones:
   empty (): detecta si el contenedor está vacío
   size (): devuelve el número de elementos válidos en el contenedor
   front (): devuelve la referencia del primer elemento en el contenedor
   push_back ( ): Inserte el elemento
   pop_back () al final del contenedor: elimine el elemento al final del contenedor

5. El vector y las clases de contenedor estándar satisfacen estas necesidades. De manera predeterminada, si no se especifica ninguna clase de contenedor para una instanciación de clase Priority_queue particular, se usa vector.

6. Los iteradores de acceso aleatorio deben ser compatibles para que la estructura de montón siempre se mantenga internamente. El adaptador de contenedor completa automáticamente esta operación llamando automáticamente a las funciones de algoritmo make_heap, push_heap y pop_heap cuando sea necesario.

Uso de prioridad_queue

La cola de prioridad usa el vector como contenedor de almacenamiento subyacente de forma predeterminada, y se utiliza un algoritmo de almacenamiento dinámico en el vector para construir los elementos en el vector en una estructura de almacenamiento dinámico. Por lo tanto, la prioridad_queue es el almacenamiento dinámico. .

Declaración de función	Descripción de la interfaz
prioridad_queue () / prioridad_queue (primero, último)	Construir una cola de prioridad vacía
vacío ()	Compruebe si la cola de prioridad está vacía, devuelva verdadero, de lo contrario devuelva falso
parte superior( )	Devuelve el elemento más grande (elemento más pequeño) en la cola de prioridad, que es el elemento superior del montón
empujar (x)	Insertar elemento x en la cola de prioridad
popular()	Elimine el elemento más grande (más pequeño) en la cola de prioridad, que es el elemento superior del montón

Nota:

1. Por defecto, prioridad_queue es un gran montón.

Código de demostración:

#include <iostream>
#include <vector>
#include <queue>
#include <functional> // greater算法的头文件
using namespace std;

void TestPriorityQueue()
{
    // 默认情况下，创建的是大堆，其底层按照小于号比较 
    vector<int> v{3,2,7,6,0,4,1,9,8,5}; 
    priority_queue<int> q1;
    for (auto& e : v)
        q1.push(e);
    cout << q1.top() << endl;   // 9
    // 如果要创建小堆，将第三个模板参数换成greater比较方式
    priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end()); 
    cout << q2.top() << endl;   // 0
}

2. Si coloca datos de tipo personalizado en priority_queue, los usuarios deben proporcionar una sobrecarga de> o <en tipo personalizado.

class Date
{
    int _year;
    int _month;
    int _day;
public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
    {}

    bool operator<(const Date& d)const
    {
        return (_year < d._year) ||
            (_year == d._year && _month < d._month) ||
            (_year == d._year && _month == d._month && _day < d._day);
    }

    bool operator>(const Date& d)const
    {
        return (_year > d._year) ||
            (_year == d._year && _month > d._month) ||
            (_year == d._year && _month == d._month && _day > d._day);
    }

    friend ostream& operator<<(ostream& _cout, const Date& d)
    {
        _cout << d._year << "-" << d._month << "-" << d._day;
        return _cout;
    } 
};

void TestPriorityQueue()
{
    // 大堆，需要用户在自定义类型中提供<的重载 
    priority_queue<Date> q1; 
    q1.push(Date(2018, 10, 29)); 
    q1.push(Date(2018, 10, 28)); 
    q1.push(Date(2018, 10, 30));
    cout << q1.top() << endl;   // 2018, 10, 30
    
    // 如果要创建小堆，需要用户提供>的重载 
    priority_queue<Date, vector<Date>, greater<Date>> q2; 
    q2.push(Date(2018, 10, 29));
    q2.push(Date(2018, 10, 28));
    q2.push(Date(2018, 10, 30));
    cout << q2.top() << endl;   // 2018, 10, 28
}

3. En algunos casos, los usuarios pueden necesitar proporcionar reglas de comparación

class Less
{
public:
    bool operator()(const Date* pLeft, const Date* pRight)
    {
        return *pLeft < *pRight;
    }
};

void TestPriorityQueue()
{
    // 自己定制比较的规则
    priority_queue<Date*, vector<Date*>, Less> q; 
    q.push(&Date(2018, 10, 29)); 
    q.push(&Date(2018, 10, 28)); 
    q.push(&Date(2018, 10, 30));
    cout << *q.top() << endl;   // 2018, 10, 30
}