队列和栈的相关面试题

1.实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)

//思路：这里我们需要两个栈s1 s2 一个正常存入数据一个只存入小的数据
//就比如说 第一个数据先入两个栈  然后插入第二个数据时 先和s2的栈顶数据
//比较 如果小的话就分别插入到s1 s2中 如果大的话就只插到s1中
#include<iostream>
#include<stack>
using namespace std;

class minStack{
public:
  minStack();
  push(int data)
  {
    s1.push(data);   //当data 小于等于s2栈顶的数据时 插入
    if(s2.empty()||s2.top()<=data)
    {
       s2.push(data);
    }
  } 
  pop(){
    if(s1.top()==s2.top())
         s2.pop();

    s1.pop();
  }
  int min()
  {
      if(s2.empty()!=NULL)
        return s2.top();
  }
  ~minStack();

private:
 stack<int> s1;
 stack<int> s2;
};

2.使用两个栈实现一个队列

//队列的特点 先进先出  而栈的特点是后进先出  要让两个栈实现一个队列的话
//我们可以这样搞  先将数据全都 存储的栈s1中  比如顺序是 1 2 3 4 5 要让先入栈的
//1先出去 这时我们可以将s1中的数据一次pop 然后存入 s2中 这时s2中的顺序就
//变成5 4 3 2 1 然后在pop掉s2中的数据这样出来刚符合先进先出的特性
//pop时我可以先看s2是否为空 不为空直接pop 为空将s1中的数据存进来然后在pop

#include<iostram>
#include<stack>
using namespace std;

class Twostack{

public:
  Twostack();
  ~Twostack();

  void Push(const int& x)
  {
     s1.push(x);
  }  
   void Pop()
   {
     if(s2.empty()!=NULL)
     {
       cout<<s2.top()<<" ";
       s2.pop();
     }else{
       while(!s1.empty())
       {
        s2.push(s1.top());
        s1.pop();
       }
       cout<<s2.top()<<" ";
       s2.pop();
     }
   }

private:
 stack<int> s1;
 stack<int> s2;
};

3.使用两个队列实现一个栈

//栈特点：后进先出 先进后出 而队列是先进先出所以想要用队列实现栈我么可以这样搞
//来两个队列 q1 q2 先将数据全部push到q1中  然后将q1中前n-1个数据pop掉然后push到q2中
//然后pop掉q1的最后一个数据就好 然后在q2实行上面步骤依次循环直到数据全部pop掉为止

#include<iostream>
#include<queue>
using namespace std;

class Twoqueue{
public:
   Twoqueue();
   ~Twoqueue();
   void push(const int& x)
   {
    if(q1.empty()&&q2.empty())
     {
        q1.push(x);
     }else if(!q1.empty())
     {
        q1.push(x);
     }else if(!q2.empty())
     {
       q2.push(x);
     }
   }
void pop()
{
  if(!q1.empty())
    {
       while(q1.size()>1)
       {
         q2.push(q1.front());
         q1.pop();
       }
       q1.pop();
    }else if(!q2.empty()) 
    {
     while(q2.size()>1)
     {
      q1.push(q2.front());
      q2.pop();
     }
     q2.pop();
    }  
 }

int & Top() 
{
  if(!q1.empty())
     return q1.back();
   if(!q2.empty())
     return q2.back();
}


private:
  queue<int> q1;
  queue<int> q2;
};

4.一个数组实现两个栈

//简单思路  先创建一个数组  栈s1从数组的头部到尾开始存储数据 
//栈s2从数组的尾到头开始存储数据  当两个栈的栈顶指针相遇时开始进行增容

#include<iostream>
using namespace std;


class Twostack
{
public:
    Twostack()
       :_array(NULL)
       ,_size1(0)
       ,_size2(0)
       ,_capacity(0)
    {}
    ~Twostack()
    {
      if(_array!=NULL)
      {
         delete [] _array;
         _array=NULL;
         _size1=0;
         _size2=0;
         _capacity=0;
      }
    }
void push1(const int & x)
{
   checkcapacity();
   _array[_size1++]=x;
}
void push2(const int& x)
{
  checkcapacity();
  _array[_size2--]=x;
}
void pop1()
{
  if(_size1==0)
    return ;
  if(_size1>0)
    --_size1;
}

void pop2()
{
   if(_size2<_capacity-1)
       _size2++;
}
int & Top1()
{
  if(Size1()==0)
    return 0;
   if(Size1()>0)
     return _array[_size-1];
}
int & Top2()
{
  if(Size2()==0)
    return 0;
    if(Size2()>0)
     return _array[_size+1];
}
size_t Size1()
{ 
  return _size;
}
size_t Size2()
{
 return _capacity-1-_size2;
}

void checkcapacity()
{
    if(_array==NULL)
     {
        _capacity+=3;
        _array=new int[_capacity];
        _size2=_capacity-1;
        return ;
     }
     if(_szie1==_size2)
     {
        int _newcapacity=_capacity*2;
        int *tmp=new int[_newcapacity];
        //拷贝s1;
        for(int i=0;i<_size1;i++)
        {
           tmp[i]=_array[i];
        }
        //拷贝s2;

        for(int j=_newcapacity-1,i=_capacity-1;i>_size2;j--,i--)
        {
           tmp[j]=_array[i];
        }
        delete[] _array;
        _array=tmp;
        _capacity=_newcapacity;
        _size2=_newcapacity-(capacity-_size2);
     }
}
private:
   int _size1;//stack1的下标
   int _size2;
   int _capacity;
   int* _array;
};