两个栈实现队列与两个队列实现栈

看到的一道面试题，要求用两个栈实现队列，然后自己写了下。今晚先写两个栈实现队列吧，明天再写两个队列实现栈。

stack  和 queue 的基本操作

1、stack

stack 模板类的定义在<stack>头文件中。
stack 模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要
的，在不指定容器类型时，默认的容器类型为deque。
定义stack 对象的示例代码如下：
stack<int> s1;
stack<string> s2;
stack 的基本操作有：
入栈，如例：s.push(x);
出栈，如例：s.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。
访问栈顶，如例：s.top()
判断栈空，如例：s.empty()，当栈空时，返回true。
访问栈中的元素个数，如例：s.size()。

2、queue

queue 模板类的定义在<queue>头文件中。
与stack 模板类很相似，queue 模板类也需要两个模板参数，一个是元素类型，一个容器类
型，元素类型是必要的，容器类型是可选的，默认为deque 类型。
定义queue 对象的示例代码如下：
queue<int> q1;
queue<double> q2;

queue 的基本操作有：

入队，如例：q.push(x); 将x 接到队列的末端。
出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。
访问队首元素，如例：q.front()，即最早被压入队列的元素。
访问队尾元素，如例：q.back()，即最后被压入队列的元素。
判断队列空，如例：q.empty()，当队列空时，返回true。
访问队列中的元素个数，如例：q.size()

 

两个stack实现queue

 1 #include <IOSTREAM>

 2 #include <QUEUE>

 3 #include <STACK>

 4 using namespace  std;

 5 

 6 /*

 7 *整体思路:

 8 *

 9 *

10 */

11 template<typename T>

12 class CQueue{

13 private:

14     stack<T>  s1;

15     stack<T>  s2;

16 public:

17     T outQueue();   //出队

18     void inQueue(T const& Data);  //入队

19 };

20 

21 template<typename T>

22 void CQueue<T>::inQueue(T const& Data)

23 {

24     s1.push(Data);

25 }

26 

27 template<typename T>

28 T CQueue<T>::outQueue()

29 {

30     while (s1.size())

31     {

32         T dataTemp = s1.top();

33         s1.pop();

34         s2.push(dataTemp);

35     }

36     if (!s2.size())

37     {

38         cout<<"Queue is Empty"<<endl;

39         return 0;

40     }

41 

42     T data = s2.top();

43     s2.pop();

44 

45     return data;

46 }

47 

48 

49 int main()

50 {

51     

52 //    int array[5] = {1,2,3,4,5};

53     CQueue<int> myQueue;

54 

55     int i =0;

56     for (i=0;i<5;i++)

57     {

58         myQueue.inQueue(i);

59     }

60     for (i=0;i<10;i++)

61     {

62         cout<<myQueue.outQueue()<<endl;

63     }

64     return 0;

65 }

 

 

两个queue 实现的stack

 1 #include <IOSTREAM>

 2 #include <QUEUE>

 3 #include <STACK>

 4 using namespace  std;

 5 

 6 template<typename T>

 7 class CStack{

 8 private:

 9     queue<T> q1;

10     queue<T> q2;

11 public:

12     T outStack();

13     void inStack(T const& data);

14 };

15 

16 

17 template<typename T>

18 void CStack<T>::inStack(T const& data)

19 {

20     q1.push(data);

21 }

22 

23 

24 template<typename T>

25 T CStack<T>::outStack()

26 {

27     while(q1.size()>1)

28     {

29         T dataTemp = q1.front();

30         q2.push(dataTemp);

31         q1.pop();

32     }

33     if (q1.size()==1)

34     {

35         T data = q1.front();

36         q1.pop();

37         return data;

38     }

39 

40     while(q2.size()>1)

41     {

42         T dataTemp = q2.front();

43         q1.push(dataTemp);

44         q2.pop();

45     }

46     if (q2.size()==1)

47     {

48         T data = q2.front();

49         q2.pop();

50         return data;

51     }

52     cout<<"the Stack is Empty"<<endl;

53     return NULL;

54 }

55 

56 

57 int main()

58 {

59     CStack<int> myStack;

60     int i =0;

61     for (i=0;i<5;i++)

62         myStack.inStack(i);

63     for (i=0;i<10;i++)

64         cout<<myStack.outStack()<<endl;

65     return 0;

66 }