栈和队列相关面试题（1）

<strong><span style="font-size:18px;">#pragma once

#include <iostream>
#include <assert.h>
using namespace std;

#include <stack>
#include <queue>

template<class T>
class TwoStack
{
public:
void Push(const T& data)
{
if (MinDataStack.empty()==true || MinDataStack.top() > data)
{
MinDataStack.push(data);
DataStack.push(data);
}
else
{
DataStack.push(data);
}
}

void Pop()
{
assert(!DataStack.empty());
if (MinDataStack.top() == DataStack.top())
{
MinDataStack.pop();
DataStack.pop();
}
else
{
DataStack.pop();
}
}

T& MinData()
{
assert(!DataStack.empty());
return MinDataStack.top();
}

T& Top()
{
assert(!DataStack.empty());
return DataStack.top();
}

bool Empty()
{
return DataStack.empty();
}

size_t Size()
{
return DataStack.size();
}

private:
stack<T> DataStack;
stack<T> MinDataStack;
};

template<class T>
class TwoStackForQueue
{
public:
void Push(const T& data)
{
InStack.push(data);
}

void Pop()
{
assert(InStack.empty() == false || OutStack.empty() == false);//如果全为空，那么则是空队列，不进行操作
while (InStack.empty() == false)
{
OutStack.push(InStack.top());
InStack.pop();
}
OutStack.pop();
}

T& Front()
{
assert(InStack.empty() == false || OutStack.empty() == false);//如果全为空，那么则是空队列，不进行操作
while (InStack.empty() == false)
{
OutStack.push(InStack.top());
InStack.pop();
}
return OutStack.top();
}

T& Back()
{
assert(InStack.empty() == false || OutStack.empty() == false);//如果全为空，那么则是空队列，不进行操作
while(OutStack.empty() == false)
{
InStack.push(OutStack.top());
OutStack.pop();
}
return InStack.top();
}

bool Empty()
{
return (InStack.empty() == true && OutStack.empty() == true);
}

size_t Size()
{
return InStack.size()+OutStack.size();
}
//友元函数
template<typename T>
friend ostream& operator<<(ostream& os, const TwoStackForQueue<T>& queue);
private:
stack<T> InStack;
stack<T> OutStack;
};

//输出运算符重载
template<class T>
ostream& operator<<(ostream& os,const TwoStackForQueue<T>& queue)
{
TwoStackForQueue<T> coutqueue(queue);

while(coutqueue.OutStack.size() > 0)
{
os<<coutqueue.OutStack.top()<<" ";
coutqueue.OutStack.pop();
}
while (coutqueue.InStack.size() > 0)
{
coutqueue.OutStack.push(coutqueue.InStack.top());
coutqueue.InStack.pop();
}
while(coutqueue.OutStack.size() > 0)
{
os<<coutqueue.OutStack.top()<<" ";
coutqueue.OutStack.pop();
}
return os;
}

template<class T>
class TwoQueueForStack
{
public:
void Push(const T& data)
{
//每次push数据，总能保证一个队列为空
if (_Queue2.empty() == true)
{
_Queue1.push(data);
}
else//_Queue1.empty() == true
{
_Queue2.push(data);
}
}

void pop()
{
assert(_Queue1.empty() == false || _Queue2.empty() == false);
if (_Queue1.empty() == false)
{
while (_Queue1.front() != _Queue1.back())
{
_Queue2.push(_Queue1.front());
_Queue1.pop();
}
_Queue1.pop();
}
else//_Queue2.empty() == false
{
while (_Queue2.front() != _Queue2.back())
{
_Queue1.push(_Queue2.front());
_Queue2.pop();
}
_Queue2.pop();
}
}

T& Top()
{
assert(_Queue1.empty() == false || _Queue2.empty() == false);
if (_Queue1.empty() == false)
{
return _Queue1.back();
}
else
{
return _Queue2.back();
}
}

bool Empty()
{
return _Queue1.empty() == true && _Queue2.empty() == true;
}

size_t Size()
{
return _Queue1.size()+_Queue2.size();
}

//template<typename T>
//friend ostream& operator<<(ostream& os,const TwoQueueForStack<T>& stack);
private:
queue<T> _Queue1;
queue<T> _Queue2;
};

//template<class T>
//ostream& operator<<(ostream& os,const TwoQueueForStack<T>& stack)
//{
//	TwoQueueForStack<T> countstack(stack);
//
//	while (countstack._Queue1.size() > 0)
//	{
//		cout<<countstack._Queue1.front()<<" ";
//		countstack._Queue1.pop();
//	}
//
//	while (countstack._Queue2.size() > 0)
//	{
//		count<<countstack._Queue2.front()<<" ";
//		countstack._Queue2.pop();
//	}
//
//	while (countstack._Queue1.size() > 0)
//	{
//		cout<<countstack._Queue1.front()<<" ";
//		countstack._Queue1.pop();
//	}
//	return os;
//}

</span></strong>

<strong><span style="font-size:18px;">#define _CRT_SECURE_NO_WARNINGS 1
#include "StackAndQueue.h"

void Test1()
{
//实现一个栈，要求实现Push（出栈）、Pop（入栈）、
//Min（返回最小值的操作）的时间复杂度为O(1)
//思路：有两个栈，每次压栈进入DataStack之前，先与MinDataStack的栈顶元素进行
//比较，如果比MinDataStack的栈顶元素小，那么数据即进入DataStack栈中也进入MinDataStack中
TwoStack<int> twostack;
twostack.Push(1);
twostack.Push(5);
twostack.Push(9);
twostack.Push(3);
twostack.Push(2);
twostack.Push(0);
twostack.Push(6);
cout<<twostack.MinData()<<endl;
cout<<twostack.Top()<<endl;
cout<<twostack.Size()<<endl;
cout<<twostack.Empty()<<endl;

twostack.Pop();
twostack.Pop();
twostack.Pop();
cout<<twostack.MinData()<<endl;
cout<<twostack.Top()<<endl;
cout<<twostack.Size()<<endl;
cout<<twostack.Empty()<<endl;
}

void Test2()
{
//使用两个栈实现一个队列
//思路：有两个栈，一个在InStack栈上只操作入栈，一个OutStack栈上只操作出栈
TwoStackForQueue<int> queue;
queue.Push(1);
queue.Push(2);
queue.Push(3);
queue.Push(4);
queue.Push(5);
queue.Push(6);
cout<<queue<<endl;

queue.Pop();
queue.Pop();
cout<<queue<<endl;

cout<<queue.Front()<<endl;
cout<<queue.Back()<<endl;
cout<<queue.Empty()<<endl;
cout<<queue.Size()<<endl;
}

void Test3()
{
//使用两个队列实现一个栈
TwoQueueForStack<int> stack;
stack.Push(6);
stack.Push(8);
stack.Push(0);
stack.Push(5);
stack.Push(9);
stack.Push(1);

stack.pop();
stack.pop();
stack.pop();
stack.pop();
stack.pop();

cout<<stack.Top()<<endl;
cout<<stack.Size()<<endl;
cout<<stack.Empty()<<endl;
}

int main()
{
//Test1();
//Test2();
//Test3();
system("pause");
return 0;
}

</span></strong>