程序博客网 > 怎样查询电信网络密码

栈与队列的实现__ 两个栈实现队列 vs 两个队列实现栈

来源：互联网 发布：怎样查询电信网络密码 编辑：程序博客网 时间：2024/06/05 03:08

栈与队列的实现

两个栈实现队列 vs 两个队列实现栈

栈(stack)规定元素是先进后出（FILO），队列(queue)是先进先出（FIFO）。

栈的实现（数组）

实现

[cpp] view plaincopyprint?
  1. #include <iostream> 
  2. #include <algorithm> 
  3. #include <iterator> 
  4. using namespace std; 
  5. const int SIZE=10; 
  6. class stack{ 
  7. public: 
  8.       stack(){ 
  9.            top=0; 
  10.       } 
  11.       boolIs_empty(){ 
  12.            if(0==top) 
  13.                  returntrue; 
  14.            else 
  15.                  returnfalse; 
  16.       } 
  17.       voidPush(int elem){ 
  18.            if(top== SIZE) 
  19.                  cout<<"stackis full."<<endl; 
  20.            else{ 
  21.                  top++; 
  22.                  array[top]=elem; 
  23.            }    
  24.       } 
  25.       intPop(){ 
  26.            if(Is_empty()) 
  27.                  cout<<"stackis empty."<<endl; 
  28.            else{ 
  29.                  top--; 
  30.                  returnarray[top+1]; 
  31.            }    
  32.       } 
  33.       intTop(){ 
  34.            if(Is_empty()) 
  35.                  cout<<"stackis empty."<<endl; 
  36.            else{ 
  37.                  returnarray[top]; 
  38.            }    
  39.       } 
  40. private: 
  41.       intarray[SIZE]; 
  42.       inttop; 
  43. }; 
  44. int main(){ 
  45.       stacks; 
  46.       s.Push(3); 
  47.       s.Push(4); 
  48.       s.Push(1); 
  49.       s.Push(10); 
  50.    cout<<s.Pop()<<endl; 
  51.       cout<<s.Pop()<<endl; 
  52.       cout<<s.Pop()<<endl; 
  53.       if(!s.Is_empty()) 
  54.            cout<<"currentTop elem: "<<s.Top()<<endl; 
  55.       cout<<s.Pop()<<endl; 
  56.       if(!s.Is_empty()) 
  57.            cout<<"currentTop elem: "<<s.Top()<<endl; 
  58.    return 0; 
  59. } 

结果


用链表实现栈：

[cpp] view plaincopyprint?
  1. #include <iostream> 
  2. using namespace std; 
  3. typedef int dataType; 
  4. struct node{   //链栈节点 
  5.       dataTypedata;            //数据域 
  6.       node*next;               //指针域 
  7. }; 
  8.   
  9. class ls{ 
  10. public: 
  11.       ls(); 
  12.       ~ls(); 
  13.       voidpush(dataType var); //压栈 
  14.       voidpop();              //出栈.出栈之前并不判断栈是否已空.需要通过isEmpty()判断 
  15.       dataTypestackTop();     //取栈顶元素,栈顶无变化.不提前判断栈是否为空 
  16.       boolisEmpty();          //判空.空返回true,反之返回false 
  17. private: 
  18.       node*top;               //栈顶指针.top=NULL表示为空栈 
  19. }; 
  20.   
  21. ls::ls(){ 
  22.       top= NULL;            //top=NULL表示链栈为空 
  23. } 
  24.   
  25. ls::~ls(){ 
  26.       node*ptr = NULL; 
  27.       while(top!= NULL){    //循环释放栈节点空间 
  28.            ptr= top->next; 
  29.            deletetop; 
  30.            top= ptr; 
  31.       } 
  32. } 
  33.   
  34. void ls::push(dataType var){ 
  35.       node*ptr = new node; 
  36.       ptr->data= var;        //新栈顶存值 
  37.       ptr->next= top;        //新栈顶指向旧栈顶 
  38.       top= ptr;              //top指向新栈顶 
  39. } 
  40.   
  41. void ls::pop(){ 
  42.       node*ptr = top->next;  //预存下一节点的指针 
  43.       deletetop;             //释放栈顶空间 
  44.       top= ptr;              //栈顶变化 
  45. } 
  46.   
  47. dataType ls::stackTop(){ 
  48.       returntop->data;       //返回栈顶元素,并不判断栈是否已空 
  49. } 
  50.   
  51. bool ls::isEmpty(){ 
  52.       returntop == NULL;     //栈顶为NULL表示栈空 
  53. } 
  54.   
  55. int main(){ 
  56.       lsexp; 
  57.       inti = 0; 
  58.       for(i=0;i<3;++i){ 
  59.            exp.push(i); 
  60.       } 
  61.       for(i=0;i<3;i++){ 
  62.            if(!exp.isEmpty()){ 
  63.                  cout<<exp.stackTop()<<endl; 
  64.                  exp.pop(); 
  65.            } 
  66.       } 
  67.       return0; 
  68. } 

队列：

[cpp] view plaincopyprint?
  1. #include <iostream> 
  2. #include <algorithm> 
  3. #include <iterator> 
  4. using namespace std; 
  5. const int SIZE=10; 
  6. class queue{ 
  7. public: 
  8.       queue(){ 
  9.            len=0;head=0;tail=0; 
  10.       } 
  11.       voidenqueue(int elem){ 
  12.            if((tail+1)%SIZE== head) 
  13.                  cout<<"queueis full."<<endl; 
  14.            else{ 
  15.                  array[tail]=elem; 
  16.                  tail= (tail+1)%SIZE; 
  17.                  len++; 
  18.            } 
  19.       } 
  20.       voiddequeue(){ 
  21.            if(tail== head) 
  22.                  cout<<"queueis empty."<<endl; 
  23.            else{ 
  24.                  cout<<array[head]<<"is out."<<endl; 
  25.                  head= (head+1)%SIZE; 
  26.                  len--; 
  27.            } 
  28.       } 
  29. private: 
  30.       intarray[SIZE]; 
  31.       inthead; 
  32.       inttail; 
  33.       intlen; 
  34. }; 
  35.   
  36. int main(){ 
  37.       queueq; 
  38.       q.enqueue(3); 
  39.       q.enqueue(4); 
  40.       q.enqueue(1); 
  41.       q.enqueue(10); 
  42.       q.enqueue(3); 
  43.       q.enqueue(4); 
  44.       q.enqueue(1); 
  45.       q.enqueue(10); 
  46.       q.enqueue(3); 
  47.       q.enqueue(4); 
  48.       q.enqueue(1); 
  49.       q.enqueue(10); 
  50.   
  51.       q.dequeue(); 
  52.       q.dequeue(); 
  53.       q.dequeue(); 
  54.       q.dequeue(); 
  55.       q.dequeue(); 
  56.    return 0; 
  57. } 

结果


用两个栈实现队列

法一：

思路：始终维护s1作为存储空间，以s2作为临时缓冲区。


步骤：入队时，将元素压入s1；出队时，将s1的元素逐个“倒入”（弹出并压入）s2，将s2的顶元素弹出作为出队元素，之后再将s2剩下的元素逐个“倒回”s1。

上述思路，可行性毋庸置疑。但有一个细节是可以优化一下的。即：在出队时，将s1的元素逐个“倒入”s2时，原在s1栈底的元素，不用“倒入”s2，可直接弹出作为出队元素返回。这样可以减少一次压栈的操作。

上述思路的一个变化：

入队时，先判断s1是否为空，如不为空，说明所有元素都在s1，此时将入队元素直接压入s1；如为空，要将s2的元素逐个“倒回”s1，再压入入队元素。

出队时，先判断s2是否为空，如不为空，直接弹出s2的顶元素并出队；如为空，将s1的元素逐个“倒入”s2，把最后一个元素弹出并出队。

相对于第一种方法，变种的s2好像比较“懒”，每次出队后，并不将元素“倒回”s1，如果赶上下次还是出队操作，效率会高一些。

法二：调整的工作在入队时


实现

[cpp] view plaincopyprint?
  1. #include <iostream> 
  2. #include <stack> 
  3. using namespace std; 
  4. template <class T> 
  5. class Queue{ 
  6. public: 
  7.       Queue(); 
  8.       ~Queue(); 
  9.       voidenqueue(const T& data); 
  10.       Tdequeue(); 
  11. //   boolisempty() const; 
  12. private: 
  13.       stack<T>s1; 
  14.       stack<T>s2; 
  15. }; 
  16.   
  17. template <class T> 
  18. Queue<T>::Queue(){ 
  19. } 
  20.   
  21. template <class T> 
  22. Queue<T>::~Queue(){ 
  23. } 
  24.   
  25. template <class T> 
  26. void Queue<T>::enqueue(const T&data){ 
  27.       if(s1.empty()) 
  28.            s1.push(data); 
  29.       else{ 
  30.            while(!s1.empty()){ 
  31.                  s2.push(s1.top()); 
  32.                  s1.pop(); 
  33.            } 
  34.            s1.push(data);       
  35.       } 
  36.       while(!s2.empty()){ 
  37.            s1.push(s2.top()); 
  38.            s2.pop(); 
  39.       }    
  40. } 
  41.   
  42. template <class T> 
  43. T Queue<T>::dequeue(){ 
  44.       Tt; 
  45.       if(!s1.empty()){ 
  46.            t=s1.top(); 
  47.            s1.pop(); 
  48.            returnt; 
  49.       } 
  50. } 
  51.   
  52. int main(){ 
  53.       Queue<int>q; 
  54.       q.enqueue(1); 
  55.       q.enqueue(5); 
  56.       q.enqueue(13); 
  57.       q.enqueue(51); 
  58.       cout<<q.dequeue()<<endl; 
  59.       q.enqueue(100); 
  60.       cout<<q.dequeue()<<endl; 
  61.       cout<<q.dequeue()<<endl; 
  62.       cout<<q.dequeue()<<endl; 
  63.       cout<<q.dequeue()<<endl; 
  64.   
  65.       return0; 
  66. } 

结果



用两个队列实现栈

其思路和两个栈实现队列类似。

[cpp] view plaincopyprint?
  1. #include <iostream> 
  2. #include <queue> 
  3. using namespace std; 
  4. template <class T> 
  5. class stack{ 
  6. public: 
  7.       stack(); 
  8.       ~stack(); 
  9.       voidpush(const T& data); 
  10.       Ttop(); 
  11.       voidpop(); 
  12. private: 
  13.       queue<T>q1; 
  14.       queue<T>q2; 
  15. }; 
  16.   
  17.   
  18. template <class T> 
  19. stack<T>::stack(){ 
  20. } 
  21.   
  22. template <class T> 
  23. stack<T>::~stack(){ 
  24. } 
  25.   
  26. template <class T> 
  27. void stack<T>::push(const T&data){ 
  28.       if(q1.empty()) 
  29.            q1.push(data); 
  30.       else{ 
  31.            while(!q1.empty()){ 
  32.                  q2.push(q1.front()); 
  33.                  q1.pop(); 
  34.            } 
  35.            q1.push(data); 
  36.            while(!q2.empty()){ 
  37.                  q1.push(q2.front()); 
  38.                  q2.pop(); 
  39.            }         
  40.       } 
  41. } 
  42.   
  43. template <class T> 
  44. void stack<T>::pop(){ 
  45.       if(!q1.empty()){ 
  46.       //   q1.front(); 
  47.            q1.pop(); 
  48.       } 
  49. } 
  50.   
  51. template <class T> 
  52. T stack<T>::top(){ 
  53.       Tt; 
  54.       if(!q1.empty()){ 
  55.            t=q1.front(); 
  56.            returnt; 
  57.       } 
  58. } 
  59.   
  60. int main(){ 
  61.       stack<int>s; 
  62.       s.push(3); 
  63.       s.push(4); 
  64.       s.push(1); 
  65.       cout<<s.top()<<endl; 
  66.       s.pop(); 
  67.       s.push(10); 
  68.       s.pop(); 
  69.    cout<<s.top()<<endl; 
  70.       s.pop(); 
  71.       cout<<s.top()<<endl; 
  72.       return0; 
  73. } 

结果

0 0
怎样查询电信网络密码 怎样查询电信网络密码
原创粉丝点击
热门IT博客
淘宝端口cd 被拒绝淘宝端口cd 被拒绝
怎样登陆阿里云服务器怎样登陆阿里云服务器
奶酪发苦 知乎
电视直播apk软件下载
hermitian矩阵
淘宝美工是干什么的
面向对象编程实例
日本读研 知乎
linux vim 分页查看
java服务器开发教程
ubuntu退出vim命令
广告新形式定制网络剧
网络外汇理财诈骗信号
r语言软件
快递查询网站源码
mac双系统安装教程win8
d3.js拓扑图教程
torrent下载软件
东易日盛做效果图软件
linux 电池电量
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 蜜芽上的东西是正品吗 蜜丫 蜜獾为什么什么都不怕 蜜獾怎么读 蜜獾霸气图片 贝爷打蜜獾是哪一期 蜜獾为什么那么记仇 蜜獾vs贝爷 蜜獾为什么不知道害怕 抖音里面很火的几张蜜獾配图 当世界末日以后 平头蜜獾 蜜粉饼 粉饼和蜜粉饼的区别 蜜粉的作用 蜜粉是什么 什么牌子的蜜粉好用 玛丽黛佳蜜粉 防晒蜜粉 那个牌子的蜜粉好用 什么蜜粉好用 哪种蜜粉好用 蜜粉哪个牌子好用 好用的蜜粉 卡姿兰蜜粉 什么是蜜粉 密粉 蜜粉在哪个步骤用 植村秀蜜粉 什么牌子蜜粉好 蜜粉什么牌子好用 资生堂蜜粉 资生堂心机蜜粉 植村秀哑光蜜粉 仙草蜜粉 黛珂蜜粉 迪奥蜜粉 矿物质蜜粉 蜜粉的正确使用方法 什么蜜粉比较好用 海蓝之谜蜜粉 蜜粉好用还是粉饼好用

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里