双栈实现队列操作

利用两个栈来实现一个队列,这里用的是自己写的栈、还有队列这两个数据结构。当然还可以利用继承的方式来实现队列，这里目前只有不用继承的方式。

原理： 
思路一： 
将stack1作为存储空间，将stack2作为临时缓冲区 
入队时：直接压入stack1 
出队时：将stack1中的元素依次压入stack2中，再将stack2的栈顶元素弹出，最后将stack2中的元素再压回给stack1

思路二： 
入队时：判断stack1是否为空，如果stack1为空，则将stack2中的所有元素都倒入stack1中，再将元素直接压入stack1，否则，直接压入stack1中 
出队时：判断stack2是否为空，如果stack2为空，则将stack1中的元素倒入stack2中，在将stack2的栈顶元素弹出，否则，直接弹出stack2的栈顶元素

思路三： 
入队时：判断stack1是否为满，没有满就存入stack1 
出队时：判断stack2是否为空，如果stack2是空，将stack1依次压入stack2，并弹出最上面的元素，如果stack2不为空，直接弹出最上面的元素

这里的my_queue没有继承my_stack，my_stack相当于是实现了栈的功能，my_queue有两个栈的对象来帮助实现队列的操作。

1. #include <iostream>
2. #include <string>
4. using namespace std;
6. template<class T>
7. class my_stack {
9. private:
10. T *l;
11. int top;//用来指向栈顶元素
13. public:
14. my_stack():top(-1)
15. {
16. l = new T[100];
17. }
18. ~my_stack()
19. {
20. delete l;
21. }
23. void pop();
24. void push(T a);
25. T top1();
26. bool isempty();
27. int size();
28. };
30. template<class T>
31. void my_stack<T>::pop()
32. {
33. if (top < 0)
34. {
35. cout << "stack is empty,pop is forbidden!" << endl;
36. //exit(0);
37. }
38. else
39. {
40. top = top - 1;
41. }
44. }
46. template<class T>
47. void my_stack<T>::push(T a)
48. {
49. if (top == 100-1)
50. {
51. cout << "stack is full!" << endl;
52. //exit(0);
53. }
54. else
55. {
56. top = top + 1;
57. l[top] = a;
58. }
59. }
61. template<class T>
62. T my_stack<T>::top1()
63. {
64. if (top != -1)
65. return l[top] ;
66. //cout << "stack is empty!" << endl;
67. //exit(0);
68. }
70. template<class T>
71. bool my_stack<T>::isempty()
72. {
73. if (top == -1)
74. return true;
75. else
76. return false;
77. }
79. template<class T>
80. int my_stack<T>::size()
81. {
82. return top + 1;
83. }
84. /*双栈实现队列思路：
85. 入队时：判断s1是否为满，没有满就存入s1
86. 出队时：判断s2是否为空，如果s2是空，将s1转入s2，弹出，如果s2不为空，直接弹出*/
87. template<class T>
88. class my_queue
89. {
90. private:
91. my_stack<T> s1, s2;
92. public:
94. my_queue()
95. {
97. }
98. ~my_queue()
99. {
100. }
102. void enqueue(T a);
103. void dequeue();
104. bool isempty();
105. int size();
106. };
108. template<class T>
109. int my_queue<T>::size()
110. {
111. return s1.size() + s2.size();
112. }
114. template<class T>
115. bool my_queue<T>::isempty()
116. {
117. return s1.isempty() && s2.isempty();
118. }
120. template <class T>
121. void my_queue<T>::enqueue(T a)
122. {
123. if (s1.top1() == 100 - 1)
124. cout << "full stack1" << endl;
125. else
126. s1.push(a);
127. }
129. template <class T>
130. void my_queue<T>::dequeue()
131. {
132. if (s2.isempty())
133. {
134. int size = s1.size();//s1的size在操作的时候会改变，所以需要另外赋值出来
135. for (int i = 0; i < size; i++) {
136. s2.push(s1.top1());
137. s1.pop();
138. }
139. s2.pop();
140. }
141. else
142. {
143. s2.pop();
144. }
145. }
147. int main()
148. {
149. my_queue<int> q1;
150. q1.enqueue(1);
151. q1.enqueue(2);
152. q1.dequeue();
154. system("pause");
155. return 0;
156. }