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;
};