队列和栈相关面试题总结

1、实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)？？
分析：
     出栈和入栈根据栈自身提供的接口不难实现，而返回最小值，我们知道遍历一次栈即可找到最小值，但是对栈的操作只能在栈顶，因此，要遍历势必要改变栈的状态，而且还要求时间复杂度为O(1),即更不能遍历栈。我们可以利用两个栈同时进行操作，一个是我们放数据的栈，而另一个栈顶专门放数据中的最小值，最后需要当前最小值，直接取第二个栈顶元素即可。



2、源代码如下：

//push出栈   ------     pop入栈           min返回最小值 ------   时间复杂度为O(1)

//不能遍历

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

template <class T>
class StackMinValue
{
public:
StackMinValue()
{}
void Pop(const T& x)
{
s.push(x);
if(min.empty())
{
min.push(x);
}
else if(min.top()>=x)
{
min.push(x);
}
}
void Push()   //出栈
{
if(min.top() == s.top() && s.size() != 1)
{
min.pop();
}
s.pop();
}
T& Min()
{
return min.top();
}
~StackMinValue()
{}
private:
stack<T> s,min;
};

int main()
{
StackMinValue<int> a;
a.Pop(3);
a.Pop(2);
cout<<a.Min();
a.Pop(5);
a.Pop(8);
a.Pop(1);
cout<<a.Min();
a.Push();
a.Push();
cout<<a.Min();
a.Push();
a.Push();
cout<<a.Min();

return 0;
}

2、使用两个栈实现一个队列
分析：栈--->先进后出                        队列--->先进先出
在进行操作时，我们可利用栈的特性，在进行push操作时，使用栈操作，而进行pop操作时将栈中元素逐一放入另一栈
源代码：

#include <iostream>
using namespace std;
#include <stack>
#include <assert.h>
template<class T>
class Queue
{
public:
Queue()
{}
void Push(const T& x)  //尾插
{
a.push(x);
}
void Pop()            //头删
{
assert(!a.empty());
while(!a.empty())
{
b.push(a.top());
a.pop();
}
b.pop();
while(!b.empty())
{
a.push(b.top());
b.pop();
}
}
size_t Size()
{
return a.size();
}
bool Empty()
{
return a.empty();
}
T& front()     //返回队头元素 -------找到再恢复
{
assert(a.empty() != true);
while (!a.empty())
{
b.push(a.top());
a.pop();
}
T tmp = b.top();
while (!b.empty())
{
a.push(b.top());
b.pop();
}
return tmp;
}
T& back()     //返回队尾元素
{
return a.top();
}
~Queue()
{}
private:
stack<T> a,b;
};
int main()
{
Queue<int> a;
a.Push(1);
a.Push(2);
a.Push(3);
cout<<a.front()<<endl;
cout<<a.Size()<<endl;
a.Push(4);
a.Pop();
cout<<a.front()<<endl;
return 0;
}

3、两个队列实现栈
思路：栈---先进后出    队列---先进先出
创建两个队列，一个队列放数据，另一个当作辅助队列，当进行push（尾插）操作时直接用队列的push进行操作，而进行pop操作时，由于队列的pop是进行头删，不符合栈pop的条件，这时可将队列1中数据从第一个开始另一辅助队列2中，但是，第一个队列中最后一个元素不放入，然后，将第一个队列清空，再将辅助队列中元素按顺序放入第一个队列中即可。
源代码：

#include <iostream>
using namespace std;
#include <queue>
#include <assert.h>
// 两个队列实现一个栈
template <class T>
class TStack
{
public:
TStack()
{}
void Push(const T& x) //进栈---尾插
{
s1.push(x);
}
void Pop()   //出栈---
{
assert(!s1.empty());
while (!s1.empty() && (s1.size()!=1))    //最后一个元素不进队列
{
s2.push(s1.front());
s1.pop();
}
s1.pop();
while (!s2.empty())
{
s1.push(s2.front());
s2.pop();
}
}
bool Empty()
{
if (s1.empty())
{
return true;
}
return false;
}
T& Top()
{
return s1.back();
}
size_t Size()
{
return s1.size();
}

private:
queue<T> s1,s2;
};

int main()
{
TStack<int> a;
a.Push(1);
a.Push(7);
a.Push(5);
a.Push(6);
cout<<a.Top()<<endl;
cout<<a.Size()<<endl;
a.Pop();
cout<<a.Size()<<endl;
cout<<a.Top()<<endl;
return 0;
}

4、一个数组实现两个栈
分析：
方案一：将数组的下标为0的位置当做第一个栈的栈底，下标为1的位置当做第二个栈的栈底，将数组的偶数位置看做第一个栈的存储空间，奇数位置看做第二个栈的存储空间。

方案二：从中间分别向两边压栈
将数组的中间位置看做两个栈的栈底，压栈时栈顶指针分别向两边移动，当任何一边到达数组的起始位置或是数组尾部，则开始扩容。

方案三：从两边向中间压栈
将数组的起始位置看作是第一个栈的栈底，将数组的尾部看作第二个栈的栈底，压栈时，栈顶指针分别向中间移动，直到两栈顶指针相遇，则扩容。

比较：方案二和方案一当两栈中元素不同时，比较浪费空间，方案三节省空间
方案3代码：
#include <iostream>
using namespace std;
#include <assert.h>
//一个数组实现两个栈
//从两边开始存
template<class T>
class Stack
{
public:
Stack()
:_arr(NULL)
,_size1(0)
,_size2(0)
,_capacity(0) //初始化容量为2
{}
void Push1(const T& x)
{
_checkcapacity();
_arr[_size1] = x;
_size1++;
}
void Pop1()
{
assert(Size1() != 0);
_size1--;
}
size_t Size1()
{
return _size1;
}
T& Top1()
{
return _arr[_size1-1];
}
void Push2(const T& x)
{
_checkcapacity();
size_t botton = _capacity-_size2-1;
_arr[botton] = x;
botton--;
_size2++;
}

void Pop2()
{
assert(Size2() != 0);
_size2--;
}
size_t Size2()
{
return _size2;
}
T& Top2()
{
assert(_size2 != 0);
return _arr[_capacity-1];
}
private:
void _checkcapacity()
{
if ((_size1+_size2)==_capacity || (_capacity==0)) //容量满 或 空
{
size_t _newcapacity = _capacity*2+2;
T* tmp = new T[_newcapacity];
for (size_t i=0; i<_size1; i++) //第一个栈放数组左边
{
tmp[i] = _arr[i];
}
size_t t = _capacity-1;
for(size_t j=_newcapacity-1; (j>(_newcapacity-_size1)) && (t>_size1-1); --t,j--)
{
tmp[j] = _arr[t];
}
_capacity = _newcapacity;
swap(_arr,tmp);
}
}
private:
T* _arr;
size_t _size1;
size_t _size2;
size_t _capacity;
};

int main()
{
Stack<int> a;
a.Push1(1);
cout<<a.Size1()<<endl;
a.Push1(8);
a.Pop1();
a.Push1(5);
a.Push1(3);
cout<<a.Size1()<<endl;
cout<<a.Top1()<<endl;
a.Push1(2);
a.Push2(1);
a.Push2(0);
a.Push2(4);
cout<<a.Size2()<<endl;
cout<<a.Top2()<<endl;
a.Push2(1);
a.Push2(1);
a.Push2(4);
a.Push2(10);
a.Pop1();
cout<<a.Size2()<<endl;
a.Pop1();
a.Pop2();
a.Pop2();
cout<<a.Size2()<<endl;
cout<<a.Top2()<<endl;
return 0;
}