zoukankan      html  css  js  c++  java
  • 简单实现C++Stack模板

    栈的特点是先进后出以及只能在栈顶进行插入和删除操作

    本次实现的栈的基本操作:

    1)弹栈

    2)压栈

    3)求栈大小

    4)求栈容量

    5)判断栈空

    6)获取栈顶元素

    1、用数组的方式实现栈基本操作

     1 /**
     2 *
     3 *作者:Ycute
     4 *时间:2019-11-15-09.55.27
     5 *题目题意简单描述:用C++模板实现栈
     6 */
     7 
     8 #include<iostream>
     9 #include<cmath>
    10 #include<cstring>
    11 #include<algorithm>
    12 #include<vector>
    13 using namespace std;
    14 
    15 template<typename T>
    16 class Stack{
    17 public:
    18     Stack();
    19     ~Stack();
    20 public:
    21     T top();//获得栈顶元素
    22     void push(T t);//入栈
    23     T pop();//出栈
    24     bool is_empty();//判断栈是否为空
    25     int size();//栈大小
    26     int capa();//栈容量
    27 private:
    28     int count;//栈元素数量
    29     int capacity;//栈容量
    30     T *array;//底层为数组
    31 };
    32 
    33 template<typename T>
    34 Stack<T>::Stack(){
    35     capacity=1000;
    36     array=new T[capacity];
    37     count=0;
    38 }
    39 
    40 template<typename T>
    41 Stack<T>::~Stack(){
    42     delete []array;
    43 }
    44 
    45 /*栈空判断*/
    46 template<typename T>
    47 bool Stack<T>::is_empty(){
    48     return count==0;
    49 }
    50 /*获得栈顶元素*/
    51 template<typename T>
    52 T Stack<T>::top(){
    53      if(count!=0){
    54         return array[count-1];
    55     }
    56     return -1;
    57 }
    58 /*入栈*/
    59 template<typename T>
    60 void Stack<T>::push(T t){
    61     if(count!=capacity){
    62         array[count++]=t;
    63     }
    64 }
    65 /*出栈*/
    66 template<typename T>
    67 T Stack<T>::pop(){
    68     if(count!=0){
    69         return array[--count];
    70     }
    71     return -1;
    72 }
    73 
    74 /*获得栈大小*/
    75 template<typename T>
    76 int Stack<T>::size(){
    77     return count;
    78 }
    79 
    80 template<typename T>
    81 int Stack<T>::capa(){
    82     return capacity;
    83 }
    84 
    85 int main(){
    86     Stack<int> s1;
    87     cout<<"栈大小"<<s1.size()<<endl;
    88     cout<<"栈容量"<<s1.capa()<<endl;
    89     s1.push(2);
    90     s1.push(3);
    91     s1.push(4);
    92     cout<<"栈是否为空"<<s1.is_empty()<<endl;
    93     cout<<"出栈"<<s1.pop()<<endl;
    94     cout<<"栈顶"<<s1.top()<<endl;
    95     cout<<"栈大小"<<s1.size()<<endl;
    96     cout<<"栈容量"<<s1.capa()<<endl;
    97     return 0;
    98 }

    2、用单链表的方式实现栈基本操作

    用一个指针,采用头插法,实现的入栈出栈

      1 /**
      2 *
      3 *作者:YCute
      4 *时间:2019-11-15-10.40.56
      5 *题目题意简单描述:用单链表实现栈
      6 */
      7 
      8 
      9 #include<iostream>
     10 #include<cmath>
     11 #include<cstring>
     12 #include<algorithm>
     13 #include<vector>
     14 using namespace std;
     15 
     16 /*栈数据节点*/
     17 template<typename T>
     18 struct Node{
     19     Node(T t):value(t),next(NULL){};
     20     Node():next(NULL){};
     21     T value;
     22     Node<T> *next;
     23 };
     24 
     25 template<typename T>
     26 class Stack{
     27 public:
     28     Stack();
     29     ~Stack();
     30 public:
     31     T top();//获得栈顶元素
     32     T pop();//出栈
     33     void push(T t);//入栈
     34     int size();//栈大小
     35     bool is_empty();//判断栈空
     36 private:
     37     int count;
     38     Node<T>* head;
     39 };
     40 
     41 template<typename T>
     42 Stack<T>::Stack(){
     43     count=0;
     44     head = new Node<T>();
     45     head->next = nullptr;
     46 }
     47 
     48 template<typename T>
     49 Stack<T>::~Stack(){
     50     while(head->next!=nullptr){
     51         Node<T> *nodeDel=head->next;
     52         head->next=head->next->next;
     53         delete nodeDel;
     54     }
     55 }
     56 
     57 /*获得栈顶元素*/
     58 template<typename T>
     59 T Stack<T>::top(){
     60     if(head->next!=nullptr){
     61         return head->next->value;
     62     }
     63 }
     64 
     65 /*出栈*/
     66 template<typename T>
     67 T Stack<T>::pop(){
     68     if(head->next!=nullptr){
     69         Node<T> *nodeDel=head->next;
     70         head->next=head->next->next;
     71         T value=nodeDel->value;
     72         delete nodeDel;
     73         --count;
     74         return value;
     75     }
     76 }
     77 
     78 /*入栈*/
     79 template<typename T>
     80 void Stack<T>::push(T t){
     81     Node <T> *subNode=new Node<T>(t);
     82     subNode->next=head->next;
     83     head->next=subNode;
     84     ++count;
     85 }
     86 
     87 /*获得栈元素*/
     88 template<typename T>
     89 int Stack<T>::size(){
     90     return count;
     91 }
     92 
     93 /*判断栈空*/
     94 template<typename T>
     95 bool Stack<T>::is_empty(){
     96     return count==0;
     97 }
     98 
     99 
    100 
    101 int main(){
    102     Stack<int> s1;
    103     s1.push(1);
    104     s1.push(2);
    105     s1.push(3);
    106     s1.push(4);
    107     cout<<"栈大小"<<s1.size()<<endl;
    108     cout<<"栈顶元素"<<s1.top()<<endl;
    109     while(!s1.is_empty()){
    110         cout<<" "<<s1.pop();
    111     }
    112     cout<<"栈大小"<<s1.size()<<endl;
    113     return 0;
    114 }
  • 相关阅读:
    排序算法 之 冒泡排序 插入排序 希尔排序 堆排序
    DataStructure之线性表以及其实现
    使用可重入函数进行更安全的信号处理
    内存经济学
    电脑通用技能
    循环套餐的逻辑
    占用了多少内存
    索引的用法
    电脑的眼缘
    字符串积木
  • 原文地址:https://www.cnblogs.com/cutelife/p/11865206.html
Copyright © 2011-2022 走看看