C++模拟实现priority_queue(优先级队列)

一、priority_queue的函数接口

从上图我们可以看出， priority_queue也是一个容器适配器，我们使用vector容器来模拟实现priority_queue。

namespace bit

{

  #include<vector>

  #include<functional>

  template <class T, class Container = vector<T>, class Compare = less<T> >

  class priority_queue

  {

  public:

    priority_queue();

    template <class InputIterator>

    priority_queue(InputIterator first, InputIterator last);

    bool empty() const;

    size_t size() const;

    T& top() const;

    void push(const T& x);

    void pop();

  private:

    Container c;

    Compare comp;

  };

};

我们主要实现的接口便是push、pop、top、size、empty。

在这里为什么要使用vector来模拟实现priority_queue呢，因为实现priority_queue就和我们实现堆一样，我们要实现对找到父亲和孩子节点，就必须要使用数组进行查找，所以实现priority_queue的底层是vector。

对于堆的知识可以移步:

二叉树详解_二叉树原理详解-CSDN博客

二、 模拟实现priority_queue

2.1 greater和less

template<class T>
struct less
{
    bool operator()(const T& x, const T& y)
    {
        return x < y;
    }
};

template<class T>
struct greater
{
    bool operator()(const T& x, const T& y)
    {
        return x > y;
    }
};

我们实现greater和less就是为了实现建大堆和建小堆，我们只能够通过修改代码父子的大于小于关系才能修改建大堆还是小堆，我们实现greater和less便可以通过模板来控制建大堆还是建小堆了。

2.2 向上调整和向下调整

void Adjustdown(size_t parent)
{
    size_t child = parent * 2 + 1;
    if (child + 1 < c.size() && comp(c[child], c[child + 1]))
    {
        child++;
    }
    while (child < c.size())
    {
        if (comp(c[parent], c[child]))
        {
            swap(c[parent], c[child]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}

void Adjustup(size_t child)
{
    size_t parent = (child - 1) / 2;
    while (child > 0)
    {
        if (comp(c[parent], c[child]))
        {
            swap(c[parent], c[child]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}

向上调整和想要调整主要是为了插入和删除后使新的数组能够重新调整为大堆或小堆，这里不再详讲，不了解的可以看:二叉树详解_二叉树原理详解-CSDN博客.

2.3 模拟实现priority_queue的构造函数

priority_queue()
{
}


template <class InputIterator>

priority_queue(InputIterator first, InputIterator last)
{
    while (first != last)
    {
        c.push_back(*first);
        ++first;
    }
    for (size_t i = c.size() - 1 - 1; i >= 0; i--)
    {
        Adjustdown(i);
    }
}

第一个无参的构造函数可以不写，因为会自动调用vector自己的构造， 而另外一个使用迭代器区间进行构造的，我们只需将每一个数据进行尾插，然后进行调整建堆即可。

2.4 模拟实现priority_queue的push

void push(const T& x)
{
    c.push_back(x);
    Adjustup(c.size() - 1);
}

 push就是将数据尾插，然后从最后一个数据开始进行向上调整，使其重新为堆。

2.5 模拟实现priority_queue的pop

void pop()
{
    swap(c[0], c[c.size() - 1]);
    c.pop_back();
    Adjustdown(0);
}

对堆进行删除，交换头和尾的数据，并将尾的数据删掉，最后从头开始向下调整，使其重新为堆。 

2.6 模拟实现priority_queue的top

T& top() 
{
    return c[0];
}

top就是获取队列首元素的值，我们直接返回下标0的数据即可。

 2.7 模拟实现priority_queue的size和empty

bool empty() const
{
    return c.empty();
}

size_t size() const
{
    return c.size();
}

 priority_queue一样使容器适配器，所以priority_queue的size和empty我们只需返回容器的size和empty即可。

2.8 检验结果

建立大堆:

建立的是大堆，每次输出后重新建堆，所以输出的是降序序列。

建立小堆:

 

 建立的是小堆，每次输出后重新建堆，所以输出的是降序序列

检测size和empty:

 push5个数据，size为5，删除一个后，size为4，empty输出0表示不为空，结果正确。

2.9 模拟实现priority_queue的完整代码

priority_queue.h文件:

#pragma once
#include<iostream>
#include<vector>
#include<functional>
using namespace std;

namespace bit

{
    template<class T>
    struct less
    {
        bool operator()(const T& x, const T& y)
        {
            return x < y;
        }
    };

    template<class T>
    struct greater
    {
        bool operator()(const T& x, const T& y)
        {
            return x > y;
        }
    };


    template <class T, class Container = vector<T>, class Compare = less<T> >

    class priority_queue

    {

    public:

        priority_queue()
        {
        }

        void Adjustdown(size_t parent)
        {
            size_t child = parent * 2 + 1;
            if (child + 1 < c.size() && comp(c[child], c[child + 1]))
            {
                child++;
            }
            while (child < c.size())
            {
                if (comp(c[parent], c[child]))
                {
                    swap(c[parent], c[child]);
                    parent = child;
                    child = parent * 2 + 1;
                }
                else
                {
                    break;
                }
            }
        }

        void Adjustup(size_t child)
        {
            size_t parent = (child - 1) / 2;
            while (child > 0)
            {
                if (comp(c[parent], c[child]))
                {
                    swap(c[parent], c[child]);
                    child = parent;
                    parent = (child - 1) / 2;
                }
                else
                {
                    break;
                }
            }
        }

        template <class InputIterator>

        priority_queue(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                c.push_back(*first);
                ++first;
            }
            for (size_t i = c.size() - 1 - 1; i >= 0; i--)
            {
                Adjustdown(i);
            }
        }

        bool empty() const
        {
            return c.empty();
        }

        size_t size() const
        {
            return c.size();
        }

        T& top() 
        {
            return c[0];
        }

        void push(const T& x)
        {
            c.push_back(x);
            Adjustup(c.size() - 1);
        }

        void pop()
        {
            swap(c[0], c[c.size() - 1]);
            c.pop_back();
            Adjustdown(0);
        }

    private:

        Container c;

        Compare comp;

    };

    void test_priority_queue1()
    {
        priority_queue<int> pq;
        pq.push(1);
        pq.push(3);
        pq.push(7);
        pq.push(0);
        pq.push(9);

        while (!pq.empty())
        {
            cout << pq.top() << " ";
            pq.pop();
        }
        cout << endl;
    }

    void test_priority_queue2()
    {
        priority_queue<int, vector<int>, greater<int>> pq;
        pq.push(1);
        pq.push(3);
        pq.push(7);
        pq.push(0);
        pq.push(9);

        while (!pq.empty())
        {
            cout << pq.top() << " ";
            pq.pop();
        }
        cout << endl;
    }
    
    void test_priority_queue3()
    {
        priority_queue<int> pq;
        pq.push(1);
        pq.push(3);
        pq.push(7);
        pq.push(0);
        pq.push(9);

        cout << pq.size() << endl;
        pq.pop();
        cout << pq.size() << endl;
        cout << pq.empty() << endl;
    }
};

 test.cpp文件:

#include"priority_queue.h"

int main()
{
	//bit::test_priority_queue1();
	//bit::test_priority_queue2();
	bit::test_priority_queue3();
	return 0;
}

三、总结

以上就是模拟实现priority_queue的全部内容，希望以上所讲能够对大家有所帮助，如果对大家有帮助的话，记得一键三连哦，感谢各位。