每天一个小算法(6)---- 通过两个栈实现一个队列

这个算法也很简单,定义两个栈m_aStack、m_bStack,m_aStack负责push()数据,m_bStack负责front()数据。

思路:每一次front()取数据都会检查一下m_bStack是否为空,为空则把m_aStack的所有数据pop()出来push()到m_bStack中。

因为STL里有stack,直接拿来用了,代码使用C++,在linux/g++下编译运行成功:

  1 #include <stack>
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include <time.h>
  5
  6 class Fifo
  7 {
  8 public:
  9     const int size() const;
 10     const bool empty() const;
 11     const int front();
 12     void push(int element);
 13     void print() const;
 14 private:
 15     std::stack<int> m_aStack;
 16     std::stack<int> m_bStack;
 17 };
 18
 19 const int Fifo::size() const
 20 {
 21     return m_aStack.size() + m_bStack.size();
 22 }
 23
 24 const bool Fifo::empty() const
 25 {
 26     return m_aStack.empty() & m_bStack.empty();
 27 }
 28
 29 const int Fifo::front()
 30 {
 31     if( empty() )
 32         return 0;
 33
 34     if ( m_bStack.empty() )
 35     {
 36         while ( !m_aStack.empty() )
 37         {
 38             m_bStack.push(m_aStack.top());
 39             m_aStack.pop();
 40         }
 41     }
 42
 43     int tmp = m_bStack.top();
 44     m_bStack.pop();
 45     return tmp;
 46 }
 47
 48 void Fifo::push(int element)
 49 {
 50     m_aStack.push(element);
 51 }
 52
 53 void Fifo::print() const
 54 {
 55     if ( empty() )
 56         return;
 57
 58     std::stack<int> tAStack = m_aStack;
 59     std::stack<int> tBStack = m_bStack;
 60
 61     printf("the elements of the m_aStack:\t");
 62     while ( !tAStack.empty() )
 63     {
 64         printf("%d ", tAStack.top());
 65         tAStack.pop();
 66     }
 67     printf("\n");
 68
 69     printf("the elements of the m_bStack:\t");
 70     while ( !tBStack.empty() )
 71     {
 72         printf("%d ", tBStack.top());
 73         tBStack.pop();
 74     }
 75     printf("\n");
 76
 77 }
 78
 79 int main(int argc, char const *argv[])
 80 {
 81     Fifo fifo;
 82     srand((int)time(0));
 83     for ( int i=0; i< 100; ++i )
 84     {
 85         if ( (rand() & 1) == 0 )
 86         {
 87             int tmp = rand()%100;
 88             printf("\npush %d to fifo\n", tmp);
 89             fifo.push(tmp);
 90             fifo.print();
 91         }
 92         else
 93         {
 94             printf("\nthe front of the fifo: %d\n", fifo.front());
 95             fifo.print();
 96         }
 97     }
 98
 99     return 0;
100 }

每天一个小算法(6)---- 通过两个栈实现一个队列

时间: 2024-10-14 06:39:03

每天一个小算法(6)---- 通过两个栈实现一个队列的相关文章

C++算法之 用两个栈实现一个队列

算法思路: 一个栈用来入队列,一个栈用来出队列: 现有两个栈s1 和s2:s1用来入栈,比如  队列进入  1 2 3 4 5 那么s1进栈 1 2 3 4 5 ,现在要出队列,意思就是要1先出来: 那么我们把栈s1的数据取出来都压到栈s2当中,那么栈s2就是 5 4 3 2 1 :s2再出栈,此时1出栈就模拟出出队列的效果: 编写代码: // QueueFrom2Stack.cpp : 定义控制台应用程序的入口点. // #include "stdafx.h" #include &l

每天一个小算法(2)----合并两个有序链表

每天一个小算法还是有点没时间,尽量抽出时间写一写. 今天是合并有序的链表,对单链表有点忘了,尤其是指针指来指去的,有点晕,幸好基础还算好,想了想还是能想回来. 代码使用随机数函数生成一个链表,然后对链表排序,最后合并链表并打印,删除链表的函数于算法无关紧要,所以未实现^_^. 在Linux/g++下编译运行成功. 合并思路:和合并数组有些类同,比较两个节点的元素大小然后将小的摘下来尾插到链表bList中,然后指针指向下一个节点,最后直接把非空的链表合并到bList的末尾. 1 #include

每天一个小算法(3)----倒序打印链表

这个比较简单,用栈.递归.倒转链表都可以实现,不再过多解释. 代码使用递归实现 1 #include <stdio.h> 2 #include <time.h> 3 #include <stdlib.h> 4 typedef struct Node 5 { 6 int data; 7 Node* next; 8 }Node, *List; 9 10 11 List createList(int num) //随机生成数字,构造链表 12 { 13 List aList

每天一个小算法(4)----在O(1)时间删除指定结点

O(1)时间内删除结点的思路只能是复制该结点下一个结点的数据,然后删除该结点的下一个结点,来等效删除此结点. 需要注意的地方是删除头结点和尾结点的处理. 1 #include <stdio.h> 2 #include <time.h> 3 #include <stdlib.h> 4 typedef struct Node 5 { 6 int data; 7 Node* next; 8 }Node, *List; 9 10 List createList(int num)

小算法:合并两个有序数组,合并之后仍然有序

1 /** 2 * 合并两个有序数组,合并后仍然有序 3 * @param a 要合并的数组A 4 * @param b 要合并的数组B 5 * @param c 合并后的数组C 6 */ 7 public static void merge(int a[] ,int b[],int c[]){ 8 int lengthA = a.length; 9 int lengthB = b.length; 10 11 int indexA = 0; 12 int indexB = 0; 13 int i

数据结构和算法之栈和队列一:两个栈模拟一个队列以及两个队列模拟一个栈

今天我们需要学习的是关于数据结构里面经常看到的两种结构,栈和队列.可以说我们是一直都在使用栈,比如说在前面递归所使用的的系统的栈,以及在链表倒序输出时介绍的自定义栈类Stack和使用系统的栈进行递归.那么,在这里我们就讲述一下这两个比较具有特色的或者说关系比较紧密的数据结构之间的互相实现问题. 一:两个栈模拟实现一个队列: 栈的特点是先进后出,然而队列的特点是先进先出. public class Queen(Stack s1,Stack s2){ //实现插入的方法 public void ad

两个栈实现一个队列和两个队列实现一个栈【算法导论课后题】

关于两个栈实现一个队列和两个队列实现一个栈问题,网上有很多资料.这里只描述自己认为操作最少的方法. 两个栈实现一个队列 思想:假设两个栈分别为s1,s2.对s1进行入队,出队时,先判断s2是否为空,如果是则将s1中元素压入s2并弹出最上面元素,如果不是,则直接弹出s2最上面的元素. <span style="font-size:18px;">EnQueue(s1,s2,k){ push(s1,k)</span><span style="font-

[算法学习]两个栈实现一个队列

问题描述: 用两个栈实现一个队列,实现两个方法:入队appendTail,出队deleteHead 分析: 第一眼就能想到两个做法, (1) 入队麻烦出队容易: 声明两个栈,一个是存数据用的栈(dataStack),一个是辅助用的栈(tempStack). 入队操作时,先将dataStack中的所有元素出栈压入tempStack中,然后将要入队的元素压入tempStack中,再将tempStack所有元素出栈到dataStack,至此入队成功,dataStack栈顶元素就是第一个入队的元素(队头

使用两个栈实现一个队列

使用两个栈Stack1和Stack2来实现一个队列.其中一个栈作为主存放数据的,另外一个栈作为临时存放数据的栈.具体操作如下: enqueue: 栈Stack1的入栈操作. dequeue:将Stack1中的元素一个一个地全部依次出栈,并且在Stack1出栈的同时把出栈的元素作为参数对Stack2进行入栈操作.这步完成之后,执行Stack2出栈操作,这时就将原先在Stack1中最先入栈的元素弹出.最后再将Stack2中的元素一个一个地全部依次出栈,填到Stack1中. 实现代码如下: /** *