栈和队列相关面试题2
2017-04-07 17:31
369 查看
题目:(1)使用两个栈实现一个队列
(2)使用两个队列实现一个栈
使用两个栈实现一个队列:
我们知道对于栈,它是先进后出,而对于队列,它是先进先出。所以用两个栈实现一个队列最直观的思路就是:
设这两个栈分别为s1,s2,始终把s1作为存储空间,把s2作为临时空间。那么
(1)入队时 把元素压入s1
(2)出队时 先把s1中除最底下所有元素都倒入s2,然后弹出s1的唯一元素,再把s2中所有元素倒回s1
可以看出s2是一个辅助空间,这样做每次出队时都要先将元素从s1倒入s2,然后再从s2倒回s1。实际上我们还有
一个做法可以减少这里的"倒"次数,性能比较高,方法如下:
(1)入队时 把元素压入s1
(2)出队时 出队时,判断s2是否为空,如不为空,则直接弹出s2的栈顶元素,如为空,则把s1的除最
底部元素外的所有元素逐个倒入s2,然后弹出s1的唯一元素
using namespace std;
const int N = 512;
template<class T>
class Stack
{
private:
T S
;
int size;
public:
void clear();
void push(const T&);
bool empty();
T pop();
};
template<class T>
void Stack<T>::clear()
{
size = 0;
}
template<class T>
void Stack<T>::push(const T &x)
{
if(size == N) return;
S[size++] = x;
}
template<class T>
T Stack<T>::pop()
{
if(size == 0) return NULL;
return S[--size];
}
template<class T>
bool Stack<T>::empty()
{
if(size == 0) return true;
return false;
}
template<class T>
class Queue
{
private:
Stack<T> s1,s2;
public:
void clear();
void push(const T&);
bool empty();
T pop();
};
template<class T>
void Queue<T>::clear()
{
s1.clear();
s2.clear();
}
template<class T>
void Queue<T>::push(const T &x)
{
s1.push(x);
}
template<class T>
T Queue<T>::pop()
{
if(!s2.empty()) return s2.pop();
while(!s1.empty())
s2.push(s1.pop());
return s2.pop();
}
template<class T>
bool Queue<T>::empty()
{
if(s1.empty() && s2.empty()) return true;
return false;
}
int main()
{
Queue<int> Q;
Q.clear();
for(int i=0;i<50;i++)
Q.push(i);
while(!Q.empty())
cout<<Q.pop()<<" ";
cout<<endl;
return 0;
}
两个队列实现一个栈:
队列是先进先出,而栈是先进后出;
考虑到我们取栈顶元素的便利性,我们在实现时使得栈顶等于队列头;
由于栈的pop弹出栈顶元素,而队列的pop也是弹出栈顶元素,所以我们需要特别处理的是插入操作。
由于往栈中添加元素相当于往队列头添加元素,因此我们需要在两个队列中进行元素的转移,比较简单的实现是:
1.q1和q2在任一时刻至少有一个为空,即如果有元素,所以元素只在同一个队列中。
2.当有元素需要插入时,将插入的元素插入到空的队列中,并将另一非空队列的元素转移到该队列中,于是插入的元素添加到了队列头中。
class Stack {
public:
// Push element x onto stack.
void push(int x) {
if (!q1.empty())
{
q2.push(x);
while (!q1.empty())
{
q2.push(q1.front());
q1.pop();
}
}
else
{
q1.push(x);
while (!q2.empty())
{
q1.push(q2.front());
q2.pop();
}
}
}
// Removes the element on top of the stack.
void pop() {
if (q1.empty()&&q2.empty())
throw new exception("stack is empty");
else if (!q1.empty()) q1.pop();
else q2.pop();
}
// Get the top element.
int top() {
if (!q1.empty()) return q1.front();
else return q2.front();
}
// Return whether the stack is empty.
bool empty() {
return (q1.empty()&&q2.empty());
}
private:
queue<int> q1, q2;
};
(2)使用两个队列实现一个栈
使用两个栈实现一个队列:
我们知道对于栈,它是先进后出,而对于队列,它是先进先出。所以用两个栈实现一个队列最直观的思路就是:
设这两个栈分别为s1,s2,始终把s1作为存储空间,把s2作为临时空间。那么
(1)入队时 把元素压入s1
(2)出队时 先把s1中除最底下所有元素都倒入s2,然后弹出s1的唯一元素,再把s2中所有元素倒回s1
可以看出s2是一个辅助空间,这样做每次出队时都要先将元素从s1倒入s2,然后再从s2倒回s1。实际上我们还有
一个做法可以减少这里的"倒"次数,性能比较高,方法如下:
(1)入队时 把元素压入s1
(2)出队时 出队时,判断s2是否为空,如不为空,则直接弹出s2的栈顶元素,如为空,则把s1的除最
底部元素外的所有元素逐个倒入s2,然后弹出s1的唯一元素
using namespace std;
const int N = 512;
template<class T>
class Stack
{
private:
T S
;
int size;
public:
void clear();
void push(const T&);
bool empty();
T pop();
};
template<class T>
void Stack<T>::clear()
{
size = 0;
}
template<class T>
void Stack<T>::push(const T &x)
{
if(size == N) return;
S[size++] = x;
}
template<class T>
T Stack<T>::pop()
{
if(size == 0) return NULL;
return S[--size];
}
template<class T>
bool Stack<T>::empty()
{
if(size == 0) return true;
return false;
}
template<class T>
class Queue
{
private:
Stack<T> s1,s2;
public:
void clear();
void push(const T&);
bool empty();
T pop();
};
template<class T>
void Queue<T>::clear()
{
s1.clear();
s2.clear();
}
template<class T>
void Queue<T>::push(const T &x)
{
s1.push(x);
}
template<class T>
T Queue<T>::pop()
{
if(!s2.empty()) return s2.pop();
while(!s1.empty())
s2.push(s1.pop());
return s2.pop();
}
template<class T>
bool Queue<T>::empty()
{
if(s1.empty() && s2.empty()) return true;
return false;
}
int main()
{
Queue<int> Q;
Q.clear();
for(int i=0;i<50;i++)
Q.push(i);
while(!Q.empty())
cout<<Q.pop()<<" ";
cout<<endl;
return 0;
}
两个队列实现一个栈:
队列是先进先出,而栈是先进后出;
考虑到我们取栈顶元素的便利性,我们在实现时使得栈顶等于队列头;
由于栈的pop弹出栈顶元素,而队列的pop也是弹出栈顶元素,所以我们需要特别处理的是插入操作。
由于往栈中添加元素相当于往队列头添加元素,因此我们需要在两个队列中进行元素的转移,比较简单的实现是:
1.q1和q2在任一时刻至少有一个为空,即如果有元素,所以元素只在同一个队列中。
2.当有元素需要插入时,将插入的元素插入到空的队列中,并将另一非空队列的元素转移到该队列中,于是插入的元素添加到了队列头中。
class Stack {
public:
// Push element x onto stack.
void push(int x) {
if (!q1.empty())
{
q2.push(x);
while (!q1.empty())
{
q2.push(q1.front());
q1.pop();
}
}
else
{
q1.push(x);
while (!q2.empty())
{
q1.push(q2.front());
q2.pop();
}
}
}
// Removes the element on top of the stack.
void pop() {
if (q1.empty()&&q2.empty())
throw new exception("stack is empty");
else if (!q1.empty()) q1.pop();
else q2.pop();
}
// Get the top element.
int top() {
if (!q1.empty()) return q1.front();
else return q2.front();
}
// Return whether the stack is empty.
bool empty() {
return (q1.empty()&&q2.empty());
}
private:
queue<int> q1, q2;
};
相关文章推荐
- 栈和队列的相关面试题
- 栈和队列相关面试题
- 【程序员面试宝典】栈和队列相关面试题
- 剑指offer编程题Java实现——面试题7相关题用两个队列实现一个栈
- 栈与队列相关面试题
- 面试题7—相关题目(两个队列实现栈)
- 栈和队列相关面试题(2)
- 栈和队列相关面试题(1)
- 栈和队列相关面试题(3)
- 栈和队列 相关 面试题
- 队列和栈相关面试题总结
- 栈和队列 相关 面试题
- 栈和队列的相关面试题
- 栈和队列相关面试题(1)
- 活动目录相关的面试题(一)
- 栈和队列面试题(二)
- 面试题28—相关题目
- java高新技术-可变参数与OverLoad相关面试题分析
- 一道有趣的面试题和相关知识补充
- 58面试题-----用两个栈实现一个队列