【无标题】

1.Stack模拟实现

由于deque在头插尾插方面效率很高，所以我们默认用deque实现

 template<class T, class Con = deque<T>>
  class stack
  {
  public:
    stack() = default;

    void push(const T& x)
    {
        _c.push_back(x);
    }

    void pop()
    {
        _c.pop_back();
    }

    T& top()
    {
        return _c.back();
    }

    const T& top()const
    {
        return _c.back();
    }

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

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

  private:
    Con _c;
  };

2.Queue模拟实现

 template<class T, class Con = deque<T>>
  class queue
  {
  public:
    queue() = default;

    void push(const T& x)
    {
        _c.push_back(x);
    }

    void pop()
    {
        _c.pop_front();
    }

    T& back()
    {
        return _c.back();
    }

    const T& back()const
    {
        return _c.back();
    }

    T& front()
    {
        return _c.front();
    }

    const T& front()const
    {
        return _c.front();
    }

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

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

  private:

    Con _c;

  };

3.priority_queue模拟实现

优先级队列相当于数据结构中的堆

//仿函数比较大小
template<class T>
struct less
{
    bool operator()(const T& left,const T& right)
    {
        return left < right;
    }
}

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


template <class T, class Container = vector<T>, class Compare = less<T>/*默认为大堆*/ >
 class priority_queue
  {
  public:

    void AdjustUp(int n)
    {
        int child = n - 1;
        int parent = (child - 1) / 2;

        while(child > 0)//这里写parent>=0会造成死循环
        {    
            if(comp(_c[parent],_c[child])
            {
                swap(_c[parent],_c[child]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
                return;              
            
        }
    }

    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 return;
        }
    }
    //创建空的优先级队列
    priority_queue():_c()
    {}

    template <class InputIterator>
    priority_queue(InputIterator first, InputIterator last):_c(first,last)
    {
        int parent = (_c.size()-2)>>1;
        while(parent>=0)
        {
            //从最后一个孩子节点的父亲节点依次向前向下调整，以建堆
            AdjustDown(parent);
            --parent;
        }

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

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

    T& top() const
    {
        return _c.front();
    }

    void push(const T& x)
    {
        _c.push_back(x);
        AdjustUp(_c.size());
    }

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

  private:
    Container _c;
    Compare comp;

  };