栈、队列

最新推荐文章于 2024-05-20 15:29:54 发布

墨客了

最新推荐文章于 2024-05-20 15:29:54 发布

阅读量915

点赞数 30

文章标签：开发语言 c++

本文链接：https://blog.csdn.net/2301_78524918/article/details/138167799

版权

1.stack的介绍和使用

1.1stack的介绍

stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

1.2 stack的使用

函数说明	接口说明
stack()	构造空的栈
empty()	检测stack是否为空
size()	返回stack中元素的个数
top()	返回栈顶元素的引用
push()	将元素val压入stack中
pop()	将stack中尾部的元素弹出

1.2.1题目带入

最小栈

思路分析：通过建立两个栈一个输入数据的站，一个最小栈，当最小栈的数据为空时将插入数据于栈顶或者输入数据栈中的数据小于最小栈栈顶的数据，则将更新最小数据插入栈顶。当pop数据时，要考虑输入栈的数据是否是最小栈的数据，如果是将一并pop.

class MinStack
{
public: 
   void push(int x)
   { 
     // 只要是压栈，先将元素保存到_elem中 _elem.push(x); 
     // 如果x小于_min中栈顶的元素，将x再压入_min中 
     if(_min.empty() || x <= _min.top()) _min.push(x); 
    } 
    void pop()
     {
       // 如果_min栈顶的元素等于出栈的元素，_min顶的元素要移除 
       if(_min.top() == _elem.top()) _min.pop(); 
       _elem.pop();
     }
     int top()
     {
       return _elem.top();
     } 
     int getMin()
    {
      return _min.top();
     }
private:
     // 保存栈中的元素
     std::stack<int> _elem;
   
     // 保存栈的最小值
     std::stack<int> _min;
};

栈的压入、弹出序列

思路分析：判断两个是否是弹出序列关系，则判断是否符合返回的标准，及将第一个数组压入另一个数组，如果不同就查看是否是因为数组数据未全部进栈，如果不是就可以确定没有关系，如果成功配对就结束循环【成功】。

class Solution {
public:
 bool IsPopOrder(vector<int> pushV,vector<int> popV) {
  //入栈和出栈的元素个数必须相同
  if(pushV.size() != popV.size()) 
  return false;
 
  // 用s来模拟入栈与出栈的过程 
  int outIdx = 0; 
  int inIdx = 0; stack<int> s; 
  while(outIdx < popV.size())
  {
   // 如果s是空，或者栈顶元素与出栈的元素不相等，就入栈 
   while(s.empty() || s.top() != popV[outIdx]) 
   {
    if(inIdx < pushV.size()) 
      s.push(pushV[inIdx++]); 
    else 
      return false; 
   }
   // 栈顶元素与出栈的元素相等，出栈 s.pop(); outIdx++; } 
   return true;
 }
};

1.2.2satck模拟内核调用

#include<iostream>
#include<vector>
#include<deque>

namespace bite
{
    template <class T,class _com=std::deque<T>>
    class stack
    {
        public:
        stack()
        {

        }
        void push(const T& date)
        {
            m_stack.push_bake(date);
            size++;
        }
        size_t size()
        {
          return m_stack.size();  
        }
        T& top()
        {
            return m_stack[size-1];
        }
        const T& top()const{
            return m_stack[size-1];
        }
        void pop()
        {
            m_stack.pop_back();
            
        }
        bool empty()
        {
            return size==0;
        }
        private:
         _com m_stack;
    }; 
}

2.queue的介绍和使用

2.1.queue介绍

1.1队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

2.2. queue的使用

函数声明	接口说明
queue()	构造空的队列
empty()	检测队列是否为空，是返回true，否则返回false
size()	返回队列中有效元素的个数
front()	返回队头元素的引用
back()	返回队尾元素的引用
push()	在队尾将元素val入队列
pop()	将队头元素出队列

queue模拟

#include<iostream>
#include<deque>

namespace bite
{
    template <class T,class _com=std::deque<T>>
    class queue
    {
        public:
        queue()
        {

        }
        void push(const T& date)
        {
            m_stack.push_back(date);
        }
        size_t size()
        {
          return m_stack.size();  
        }
        T& top()
        {
            return m_stack[size()-1];
        }
        const T& top()const{
            return m_stack[size()-1];
        }
        void pop()
        {
            m_stack.pop_back();
            
        }
        bool empty()
        {
            return size==0;
        }
        private:
         _com m_stack;
    };

3.priority_queue的介绍和使用

3.1的介绍

优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

3.2 priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。

函数声明	接口说明
priority_queue()/priority_queue(ﬁrst,last)	构造一个空的优先级队列
empty( )	检测优先级队列是否为空，是返回true，否则返回false
top( )	返回优先级队列中最大(最小元素)，即堆顶元素
push(x)	在优先级队列中插入元素x
pop()	删除优先级队列中最大(最小)元素，即堆顶元素

3.3 在OJ中的使用

数组中的第K个最大元素

class Solution {
public:
 int findKthLargest(vector<int>& nums, int k) {
 // 将数组中的元素先放入优先级队列中
 priority_queue<int> p(nums.begin(), nums.end());
 
 // 将优先级队列中前k-1个元素删除掉 for(int i= 0; i < k-1; ++i) {
 p.pop();
 }
 
 return p.top();
 }
};

3.4伪函数（伪函数对象）

在模板元编程中，有时会使用类或结构来模拟函数的行为，这些类或结构通常包含一个或多个模板特化的操作符重载，以模仿函数调用的语法。这些类或结构可以被视为“伪函数对象”，因为它们看起来像是函数，但实际上是通过对象来调用的。

template <typename T>  
struct add {  
    T operator()(T a, T b) const {  
        return a + b;  
    }  
};  
  
int main() {  
    add<int> adder;  
    int result = adder(3, 4); // 调用伪函数对象  
    return 0;  
}

模拟priority_queue

#include<iostream>
#include<deque>
namespace bite
{
    //伪函数
    //仿函数中的成员函数不能在本类中重载，需要重载的再写一个类。
    template<class T>
    class less
    {
    public:
       bool operator()(const T& x, const T& y)
        {
            return x < y;
        }
    };
    template<class T>
    class head
    {
    public:
        bool operator()(const T lhs,const T  rhs)
       {
           return lhs<rhs;
       }
       bool operator()(const T*lhs,const T* rhs)
       {
           return *lhs<*rhs;
       }
    };
    template<class T,class C>
    class gred
    {
      bool operator()(const T*lhs,const T* rhs)
       {
           return *lhs<*rhs;
       }
    };
    template <class T,class _com=std::deque<T>,class _com2=less<T>>
    class priority_queue
    {
        public:
        priority_queue()
        {

        }
        void quequ(size_t n)
        {
            _com2 com;
            size_t nin=n*2+1;
            while(nin<m_stack.size())
            {
                if(com(nin+1,m_stack.size())&&com(m_stack[nin],m_stack[nin+1]))
                {
                    nin+=1;
                }
                if(com(m_stack[n],m_stack[nin]))
                {
                    std::swap(m_stack[nin],m_stack[n]);
                    n=nin;
                    nin=n*2+1;
                }
                else
                {
                    break;
                }
            }
        }
        void kuequeu()
        {  int i=m_stack.size()-1;
           for(;i>=0;i--)
           quequ(i);
        }
        void push(const T& date)
        {
            m_stack.push_back(date);
            kuequeu();
           
        }
        size_t size()
        {
          return m_stack.size();  
        }
        T& top()
        {
            return m_stack[0];
        }
        const T& top()const{
            return m_stack[0];
        }
        void pop()
        {
            std::swap(m_stack[0],m_stack[m_stack.size()-1]);
            m_stack.pop_back();
           quequ(0);
          
        }
        bool empty()
        {
            return size==0;
        }
        private:
         _com m_stack;
    };

4.容器适配器

4.1 什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

4.2 STL标准库中stack和queue的底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，比如：

4.3 deque的简单介绍(了解)

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

那deque是如何借助其迭代器维护其假想连续的结构呢？

墨客了

关注

30
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
栈、队列

stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。1.1队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
复制链接

扫一扫