STL栈:
入栈:s.push(x); 出栈:s.pop()无返回值; 返回栈顶s.top()s.empty(),s.size()....
STL队列:
入队:q.push(x)放到队列的末端;出队:q.pop()弹出队首无返回值
q.front()返回队首;q.back()返回队尾q.empty(),q.size().....
(1)队列 <----->栈
两个栈实现一个队列(剑指offer7):
------栈A负责输入,栈B负责输出,输入时直接放入栈A,输出时先从栈B输出,若栈B为空,将栈A全部放入栈B再输出
template
class myQueue
{
public:
myQueue();
~myQueue();
void append(const T& node);
T deleteHead();
private:
stack s1;
stack s2;
};
template
myQueue::myQueue()
{
}
template
myQueue::~myQueue()
{
}
template
void myQueue::append(const T& node)
{
s1.push(node);
}
template
T myQueue::deleteHead()
{
if(s2.empty())
while(!s1.empty()){
s2.push(s1.top());
s1.pop();
}
if(s2.empty()){
cout<<"empty";
return (T)0;
}
T tmp = s2.top();
s2.pop();
return tmp;
}
两个队列实现一个栈:
每次插入的时候,将元素插入到空队列中,然后将另一个队列元素转移进来;输出时直接从非空输出。
这样所有的元素都在一个队列中以栈的顺序存在
template
class myStack
{
public:
myStack();
~myStack();
void push(const T& node);
T top();
void pop();
bool empty();
private:
queue q1;
queue q2;
};
template
myStack::myStack()
{
}
template
myStack::~myStack()
{
}
template
void myStack::push(const T& node)
{
if(q1.empty()){
q1.push(node);
while(!q2.empty()){
q1.push(q2.front());
q2.pop();
}
}else{
q2.push(node);
while(!q1.empty()){
q2.push(q1.front());
q1.pop();
}
}
}
template
T myStack::top()
{
if(q1.empty() && q2.empty()){
cout << "empty";
return (T)0;
}
if(q1.empty())
return q2.front();
else
return q1.front();
}
template
void myStack::pop()
{
if(q1.empty() && q2.empty()){
cout << "empty";
return ;
}
if(q1.empty())
q2.pop();
else
q1.pop();
}
template
bool myStack::empty()
{
return (q1.empty() && q2.empty());
}
(2)用栈进行逆序bool isPopOrder(const int* push,const int* pop,int length)
{
if(push == NULL || pop == NULL || length <= 0)
return false;
stack s;
const int* index1 = push;
const int* index2 = pop;
while(index1 - push < length){
s.push(*index1);
index1++;
while(!s.empty() && *index2 == s.top())
{
s.pop();
++index2;
}
}
if(s.empty() && index2 - pop == length)
return true;
return false;
}
(4)包含min方法的栈,用以获取最小值(剑指offer21)当数据栈弹出一个数据时,辅助栈也弹出一个数据
(5)栈的逆序
给定一个栈,将栈逆序原地翻转,不能使用其他的辅助数据结构
解题思路:利用递归的思想,实现一个获取并弹出栈底元素的函数
void reverseStack(stack& s)
{
if(s.empty())
return;
int base = getBase(s);
reverseStack(s); //对剩下的元素进行递归
s.push(base);
}
//获取并弹出栈底元素
int getBase(stack&s)
{
int base = s.top();
s.pop();
if(s.empty()){
return base;
}else{
int last = getBase(s);
s.push(base); // 把之前弹出的元素放回
return last;
}
}
实际上使用了栈内存将数据以参数的形式保存了起来,和用辅助空间没什么区别。
注意:int getBase(stack
(6)双栈排序
借助辅助栈,每次将顶元素正确“插入”到栈中
void SortStack(stack& st)
{
if(st.empty())return;
int topNum = st.top();
st.pop();
SortStack(st);//顶元素弹出,将下面的排好
stack tempSt;
while(!st.empty() && st.top()>topNum){
tempSt.push(st.top());
st.pop();
}
st.push(topNum);
while(!tempSt.empty()){
st.push(tempSt.top());
tempSt.pop();
}
}
解题思路:使用双端队列保存最大值的坐标,并且按情况进行更新
vector maxInWindows(const vector& nums, unsigned int size)
{
vector result;
if(nums.size() < size || size <= 0)
return result;
//使用双端队列保存当前可能成为最大值的点的下标,并且队头元素为当前最大值下标
deque index;
//处理窗口还没有满的情况
for(int i = 0; i < size; ++i){
//发现一个比之前下标大的点,那么前面的点全部出队
while(!index.empty() && nums.at(i) >= nums.at(index.back()))
index.pop_back();
index.push_back(i);
}
for(int i = size; i < nums.size() ;++i){
result.push_back(nums.at(index.front())); //首先保存当前结果
//同上,先将队尾不可能成为最大值的下标删除
while(!index.empty() && nums.at(i) >= nums.at(index.back()))
index.pop_back();
//当前front元素已经不再区间里面,则队头删除
if(!index.empty() && index.front() <= (i-size))
index.pop_front();
index.push_back(i);
}
result.push_back(nums.at(index.front()));
return result;
}
(8)遇到计算表达式(leetcode150)["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
简化路径(leetcode71)"/a/./b/../../c/"
, => "/c"
这种遇到一个数据需要取出前面的数据进行计算的情况,都应该利用栈的后入先出特性
(9)递归和栈可以进行相互转换,有时候用递归可以优化代码结构,如逆序打印链表可以这么写:
void reversePrint(ListNode* head)
{
if(head == NULL)
return;
reversePrint(head->next);
cout<val;
}