【c++】模拟实现优先级队列（priority_queue）

全部代码

以容器适配器的玩法来实现，底层容器默认为vector
使用了模板参数T表示存储在队列中的元素类型，Container表示底层容器类型，默认为vector，Compare表示比较器类型，默认为less。
adjustDown函数用于向下调整堆，保持堆的性质。它从指定的父节点开始，将其与子节点进行比较，如果子节点的值更大，则交换父节点和子节点的位置，并继续向下调整直到满足堆的性质。
adjustUp函数用于向上调整堆，保持堆的性质。它从指定的子节点开始，将其与父节点进行比较，如果子节点的值更大，则交换父节点和子节点的位置，并继续向上调整直到满足堆的性质。
构造函数可以接受一个迭代器范围[first, last]，用于初始化优先队列。在构造过程中，首先将迭代器范围内的元素存储到底层容器中，然后从最后一个非叶子节点开始，依次调用adjustDown函数，使得整个容器满足堆的性质。
empty函数用于判断优先队列是否为空，即底层容器是否为空。
size函数用于返回优先队列中元素的个数，即底层容器的大小。
top函数用于返回优先队列中的最大元素（根节点），但并不删除该元素。
push函数用于将一个元素插入到优先队列中。它将元素添加到底层容器的末尾，并调用adjustUp函数向上调整堆。

pop函数用于删除优先队列中的最大元素（根节点）。它首先将根节点与最后一个叶子节点交换位置，然后删除最后一个叶子节点，并调用adjustDown函数向下调整堆。

#pragma once
#include<vector>
namespace hqj
{
template <class T, class Container = vector<T>, class Compare = less<T> >

  class priority_queue

  {
  private:
      void adjustDown(int parent)
      {
          int child = parent * 2 + 1;

          while (child < _c.size())
          {
              if (child + 1 < _c.size() && _comp(_c[child], _c[child+1]))
              {
                  child++;
              }

              if (_comp(_c[parent], _c[child]))
              {
                  swap(_c[parent], _c[child]);
                  parent = child;
                  child = parent * 2 + 1;
              }
              else
              {
                  break;
              }
           
          }
      }

      void adjustUp(int child)
      {
          int 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;
              }
          }
      }
  public:

      priority_queue()
      {}

      template <class InputIterator>

      priority_queue(InputIterator first, InputIterator last)
          :_c(first,last)
      {
          for (int 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() const
      {
          return (T&)_c.front();
      }

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

      void pop()
      {
          swap(_c.front(), _c.back());
          _c.pop_back();
          adjustDown(0);
      }

  private:

      Container _c;

      Compare _comp;

  };

};

私有成员

_c容器对象:缺省的容器类型是vector
_comp比较器对象

Container _c;
Compare _comp;

构造函数

由于我们模拟实现的优先级队列是一个容器适配器，私有成员中不含内置类型。利用系统生成的默认构造函数特性，会自动调用私有成员的构造函数，所以我们可以不写该优先级队列的构造函数的内容

priority_queue()
{}

析构函数

同理根据系统默认生成的析构函数特性，当对象销毁时会自动调用自定义类型的析构函数，我们也可以不写

向下调整函数

向下调整函数的参数是父节点的下标
首先我们通过父亲下标找到其左孩子
随后我们通过比较左右孩子大小来确定父亲要与哪个孩子进行比较、交换，至于是选择较大孩子还是较小孩子要根据比较器_comp的返回值来确定，如果我们想建小堆则选取较小的孩子；若我们要建大堆，则选取较大的孩子
交换父亲和孩子，并且更新父亲和孩子

由于向下调整次数不一定唯一，我们需要用到while结构，循环终止条件为：child下标越界、父子间的大小关系不满足比较器的要求。

void adjustDown(int parent)
{
int child = parent * 2 + 1;

        while (child < _c.size())
        {
            if (child + 1 < _c.size() && _comp(_c[child], _c[child+1]))
            {
                child++;
            }

            if (_comp(_c[parent], _c[child]))
            {
                swap(_c[parent], _c[child]);
                parent = child;
                child = parent * 2 + 1;
            }
            else
            {
                break;
            }
         
        }
    }

向上调整函数

向上调整函数的参数是孩子的下标
首先通过孩子的下标找到父亲的下标
当父子关系满足比较器_comp的要求时进行调整，交换父亲和孩子，并更新父亲和孩子的下标

同样，向上调整不止一次，需要用到while结构，循环终止条件为：孩子为根节点、父亲和孩子间的大小关系不满足比较器_comp要求

void adjustUp(int child)
    {
        int 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;
            }
        }
    }

迭代器构造函数

由于模拟实现的优先级队列是容器适配器，直接使用底层容器的迭代器构造就行了，读入要建堆的数据
都读入后，先找到最后一个叶子节点的父亲节点，随后传递该节点下标进向下调整函数，开始依次向下调整

以arr数组为例：

 priority_queue(InputIterator first, InputIterator last)
        :_c(first,last)
    {
        for (int i = _c.size() - 1 - 1; i >= 0; i--)
        {
            adjustDown(i);
        }
    }

empty函数

还是底层容器接口的复用，调用底层容器的empty函数

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

size函数

底层容器接口的复用，调用底层容器的size函数

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

top函数

函数作用是返回优先级队列队头元素（也就是堆顶元素），而该元素正好是底层容器的首元素，复用front接口就行，记得要强转
```
   T& top() const
   {
       return (T&)_c.front();
   }
```

push函数的实现

调用底层容器的push_back函数实现插入功能，然后再进行向上调整堆

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

pop函数的实现

首先交换队头元素和队尾元素（堆顶元素和堆尾元素）
将队尾元素删除

从堆顶开始向下调整堆

    void pop()
    {
        swap(_c.front(), _c.back());
        _c.pop_back();
        adjustDown(0);
    }