http://blog.csdn.net/hanjing_1995/article/details/51539578

使用两个栈实现一个队列

思路一：

我们设定s1是入栈的，s2是出栈的。

入队列，直接压到s1即可

出队列，先把s1中的元素倒入到s2中，弹出s2中的栈顶元素；再把s2的剩余元素全部倒回s1中。

缺点：

每次只要出栈一个元素就要将元素倒来倒去，麻烦！！！

思路2：

入队列时：
如果s1为空，把s2中所有的元素倒出压到s1中。否则直接压入s1

出队列时：
如果s2不为空，把s2中的栈顶元素直接弹出。否则，把s1的所有元素全部弹出压入s2中，再弹出s2的栈顶元素

思路1无条件地每次都要将元素倒来倒去，思路2出队时较思路1简单

思路3：

我们设定s1是入栈的，s2是出栈的

入队列：直接压入元素至s1即可

出队列：如果s2不为空，把s2中的栈顶元素直接弹出。否则，把s1的所有元素全部弹出压入s2中，再弹出s2的栈顶元素

相比于方法2，入队直接压入即可~

那么，我们可以看出，思路三最简单，我们下面看下代码。

代码实现：

1）我们直接调用库里的stack来实现。（一般调用库里的就行了）

[cpp] view plain copy
  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<iostream>
  3. using namespace std;
  4. //两个栈实现一个队列
  5. #include<stack>
  6. template<class T>
  7. class Queue
  8. {
  9. public:
  10. void appendTail(const T& x)
  11. {
  12. s1.push(x);
  13. }
  14. void deleteHead()
  15. {
  16. if (s2.empty())
  17. {
  18. while (!s1.empty())
  19. {
  20. s2.push(s1.top());
  21. s1.pop();
  22. }
  23. cout << s2.top() << "  ";
  24. s2.pop();
  25. }
  26. else
  27. {
  28. cout << s2.top() << "  ";
  29. s2.pop();
  30. }
  31. }
  32. private:
  33. stack<T> s1;
  34. stack<T> s2;
  35. };
  36. void Test()
  37. {
  38. Queue<int> q;
  39. q.appendTail(1);
  40. q.appendTail(2);
  41. q.appendTail(3);
  42. q.appendTail(4);
  43. q.deleteHead();
  44. q.deleteHead();
  45. q.deleteHead();
  46. q.deleteHead();
  47. }
  48. int main()
  49. {
  50. Test();
  51. system("pause");
  52. return 0;
  53. }

2）自己实现栈实现。

[cpp] view plain copy
  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<iostream>
  3. using namespace std;
  4. #include<assert.h>
  5. //直接实现Stack，也可以用适配器实现栈，或者用库。
  6. //将Stack基本功能实现如下：
  7. template<class T>
  8. class Stack
  9. {
  10. public:
  11. Stack()
  12. :_array(NULL)
  13. , _size(0)
  14. , _capacity(0)
  15. {}
  16. Stack<T>(const Stack<T>& s)
  17. : _array(new T[s._capacity])
  18. {
  19. swap(_array, s._array);
  20. swap(_size, s._size);
  21. swap(_capacity, s._capacity);
  22. }
  23. Stack<T>& operator=(const Stack<T>& s)
  24. {
  25. if (&s != this)
  26. {
  27. swap(_array, s._array);
  28. swap(_size, s._size);
  29. swap(_capacity, s._capacity);
  30. }
  31. return *this;
  32. }
  33. ~Stack()
  34. {
  35. if (_array)
  36. {
  37. delete[] _array;
  38. _array = NULL;
  39. }
  40. }
  41. void _CheckCapacity()
  42. {
  43. if (_size == 0)
  44. {
  45. _capacity = 3;
  46. _array = new T[_capacity];
  47. }
  48. if (_size >= _capacity)
  49. {
  50. _capacity *= 2;
  51. T* tmp = new T[_capacity];
  52. for (int index = 0; index < _size; index++)
  53. {
  54. tmp[index] = _array[index];
  55. }
  56. delete[] _array;
  57. _array = tmp;
  58. }
  59. }
  60. void Push(const T& x)
  61. {
  62. _CheckCapacity();
  63. _array[_size++] = x;
  64. }
  65. void Pop()
  66. {
  67. if (_size == 0)
  68. {
  69. return;
  70. }
  71. --_size;
  72. }
  73. size_t Size()
  74. {
  75. return _size;
  76. }
  77. bool Empty()
  78. {
  79. return Size() == 0;
  80. }
  81. T& Top()
  82. {
  83. assert(_size > 0);
  84. return _array[_size - 1];
  85. }
  86. private:
  87. T* _array;
  88. size_t _size;
  89. size_t _capacity;
  90. };
  91. template<class T>
  92. class Queue
  93. {
  94. public:
  95. void InQueue(const T& x)
  96. {
  97. s1.Push(x);
  98. }
  99. void OutQueue()
  100. {
  101. //栈s2为空，则将栈s1的元素全部倒入s2中，再弹出最上面的那个元素
  102. if (s2.Empty())
  103. {
  104. while (!s1.Empty())
  105. {
  106. s2.Push(s1.Top());
  107. s1.Pop();
  108. }
  109. s2.Pop();
  110. }
  111. //栈s2不为空，直接弹出元素
  112. else
  113. {
  114. s2.Pop();
  115. }
  116. }
  117. void Print()    //打印队列元素，分四种情况。
  118. {
  119. if (s1.Empty() && s2.Empty())
  120. {
  121. cout << "The Queue is Empty!";
  122. }
  123. else if (!s1.Empty() && s2.Empty())
  124. {
  125. while (!s1.Empty())
  126. {
  127. s2.Push(s1.Top());
  128. s1.Pop();
  129. }
  130. while (!s2.Empty())
  131. {
  132. cout << s2.Top() << "  ";
  133. s2.Pop();
  134. }
  135. }
  136. else if (s1.Empty() && !s2.Empty())
  137. {
  138. while (!s2.Empty())
  139. {
  140. cout << s2.Top() << "  ";
  141. s2.Pop();
  142. }
  143. }
  144. else
  145. {
  146. while (!s2.Empty())
  147. {
  148. cout << s2.Top() << "  ";
  149. s2.Pop();
  150. }
  151. while (!s1.Empty())
  152. {
  153. s2.Push(s1.Top());
  154. s1.Pop();
  155. }
  156. while (!s2.Empty())
  157. {
  158. cout << s2.Top() << "  ";
  159. s2.Pop();
  160. }
  161. }
  162. cout << endl;
  163. }
  164. private:
  165. Stack<T> s1;    //入队
  166. Stack<T> s2;    //出队
  167. };
  168. //测试两个栈实现一个队列
  169. void Test1()
  170. {
  171. Queue<int> q1;
  172. q1.InQueue(1);
  173. q1.InQueue(2);
  174. q1.InQueue(3);
  175. q1.InQueue(4);
  176. /*q1.Print();*/
  177. q1.OutQueue();
  178. /*q1.Print();*/
  179. q1.InQueue(5);
  180. q1.InQueue(6);
  181. q1.InQueue(7);
  182. q1.Print();
  183. }
  184. int main()
  185. {
  186. Test1();
  187. system("pause");
  188. return 0;
  189. }

(1个细节)：

注意再将元素倒入另一个栈时，代码并不是先pop,再push。因为这样push后元素就找不到了。因此要先访问到栈顶元素top,再push,而后pop。

本文出自 “Han Jing's Blog” 博客，请务必保留此出处http://10740184.blog.51cto.com/10730184/1763006

【数据结构】（面试题）使用两个栈实现一个队列(详细介绍)相关推荐

  1. 数据结构：栈和列之如何用两个队列实现一个栈？两个栈实现一个队列？

    1.栈和队列分析 栈是一种特殊的线性表.其特殊性在于限定插入和删除数据元素的操作只能在线性表的一端进行 队列(Queue)也是一种运算受限的线性表,它的运算限制与栈不同,是两头都有限制,插入只能在表的 ...

  2. 记一道面试题：STL两个栈实现一个队列。

    面试题目 STL两个栈实现一个队列. 要求:只能使用栈的pop(),top()和push(),以及测试栈是否为空 empty()四个操作. 来实现队列的clear(), push(),pop(),ba ...

  3. 算法图解：如何用两个栈实现一个队列？

    作者 | 王磊 来源 | Java中文社群(ID:javacn666) 转载请联系授权(微信ID:GG_Stone) 本文已收录至 https://github.com/vipstone/algori ...

  4. 包含min函数的栈和两个栈实现一个队列

    题目:定义栈的数据结构,要求添加一个min函数,能够得到栈的最小元素.要求函数min.push以及pop的时间复杂度都是O(1). 分析:这是google的一道面试题. 看到这道题目时,第一反应就是每 ...

  5. java 栈和队列实现迷宫代码_算法图解：如何用两个栈实现一个队列？

    本文已收录至 https://github.com/vipstone/algorithm <算法图解>系列. 队列和栈是计算机中两个非常重要的数据结构,经过前面的学习(<队列> ...

  6. 两个栈实现一个队列，两个队列实现一个栈

    题目:用两个栈实现一个队列,用两个队列实现一个栈. 首先要了解栈和队列这两种数据结构各自的特点,栈是一种后入先出(Last In First Out,LIFO)的数据结构,队列是一种先进先出(Firs ...

  7. 由两个栈组成一个队列

    使用C++完成<程序员代码面试指南 IT名企算法与数据结构题目> 题目 编写一个类,用两个栈实现队列,支持队列操作: - push:入队 - pop:出队(不返回值) - front:返回 ...

  8. 多态指针访问虚函数不能被继承的类快速排序N皇后问题插入排序堆排序merge归并排序栈上生成对象两个栈实现一个队列...

    多态 /*1. 要想实现覆盖(重写)父类必须声明为virtual,子类可以不声明为virtual.-->FunB()2. 派生类重写基类的虚函数实现多态,要求函数名.参数列表.返回值完全相同.( ...

  9. 【剑指offer】用两个栈实现一个队列

    题目:两个栈实现一个队列. 栈的特点:先进后出,队列的特点是先进先出 思路:stack1放入数据:pop时,先判断stack2是否为空,如果不为空,直接pop,如果空,则push(stack1.pop ...

最新文章

  1. 香港理工大学计算机专业课程,香港理工大学 19年入学 计算机硕士信息一览
  2. curl学习(实例不断总结)
  3. 图解SQL子查询实例
  4. T-SQL 中ON和WHERE的区别
  5. 由for V.S. for each想到的
  6. mysql解压rpm文件在哪_[mysql] mysql 源码安装解压 rpm 包命令
  7. sun java认证真题,sun scjp考试心得_java认证
  8. 网页版结题报告html没了,[转载]我的结题报告
  9. php sqlhelper,php中分页及SqlHelper类用法实例
  10. 系统架构设计师：软件开发基础知识
  11. 好课堂Scratch编程08 趣学篇（四）密林深处的危险气息
  12. uniapp 自定义模板
  13. 重整晋商雄风，再现汇通天下 -------《晋商》阅读笔记第5-6章
  14. mac photoshop cs5.1 序列号
  15. U盘, USB读卡器, U盘读卡器三者技术分析区别
  16. PEAP认证环境搭建及认证的大体流程
  17. RS-一般推荐(CF系列)-2018：GCMC
  18. 城市物流管理系统的设计与实现
  19. xposed的总开关
  20. android WebView加载视频只有声音没有画面

热门文章

  1. sublime text3 使用SVN插件
  2. ajax eval html,Ajax eval的应用示例
  3. linux算法平台,Linux实时调度算法与测试平台的研究与实现
  4. python 浏览器显示本地文件夹_浏览器读取本地文件
  5. 计算机二级目录设置,word2设置标题格式,生成目录,奇偶页设置等等,适用考计算机二级办公软件,也适用于毕业论文格式设置...
  6. linux编译ffmpeg成so,「ffmpeg」一 mac 环境下编译ffmpeg，生成so库文件
  7. java程序日期转换_Java 日期转换详解及实例代码
  8. JavaScript学习随记——对象
  9. C++11的静态断言
  10. java和c++的区别大吗_大空间消防水炮ZDMS0.8/30S坐装和吊装有区别吗?