栈

栈（stack）（数据结构中的栈）是一种动态集合，且在其上进行delete操作所移除的元素
是预先设定的。被删除的元素是最近插入的元素：栈实现的是一种后进先出的策略。
栈分为顺序栈和链栈，下面就两种栈分别用c＋＋实现其基本功能。
一、顺序栈：（c++实现）

1. 1.

#include <iostream> 
using namespace std;
//顺序栈; 
template <typename T> 
class stack
{ public:    
//构造函数;    
stack()    
{
    m_iTop = -1;
    memset(m_Array, 0, sizeof(m_Array));    
}
//析构函数;    
~stack()  
{
}
private:    
//栈的容量;    
enum {m_iCapacity = 10};    
//指向栈顶的索引;    
int         m_iTop;    
//存储数据的数组;    
T           m_Array[m_iCapacity]; 
public:    
//判断栈空;    
bool isEmpty()    
{
   f (m_iTop == -1) 
   {
       return true; 
   }

   return false;  
}    
//判断栈满;    
bool isFull()    
{
  if (m_iTop == m_iCapacity - 1)
  {
    return true;
  }
  return false;    
}    
//入栈;    
void push_back(T _element)    
{
           if (isFull())
           {
               cout<<"stack is full!"<<endl;
               return;
           }

           m_iTop++;
           m_Array[m_iTop] = _element;    
}    
//出栈;    
void pop_back()    
{
           if (isEmpty())
           {
               cout<<"stack is empty!"<<endl;
               return;
           }

           m_Array[m_iTop] = NULL;
           m_iTop--;
}    
//清空栈;  
void clear()    
{
           memset(m_Array, 0, sizeof(m_Array));
           m_iTop = -1;    
}    
//获得栈中元素数目;    
int size()  
{
           return (m_iTop+1);   
}    
//获得栈顶元素;    
int getPopElement()    
{
           if (isEmpty())
           {
               cout<<"stack is empty!"<<endl;
               return NULL;
           }

           return m_Array[m_iTop];    
}
};

//测试代码;
stack<int> _stack;

if (_stack.isEmpty())
{
    cout<<"_stack is empty"<<endl;
}
cout<<" "<<_stack.getPopElement()<<endl;

for (int j = 0; j<15; j++)
{
    _stack.push_back(j);
}
cout<<" "<<_stack.getPopElement()<<endl;

cout<<"_stack size : "<<_stack.size()<<endl;

_stack.pop_back();

cout<<"_stack size : "<<_stack.size()<<endl;

for (int j = 0; j<16; j++)
{
    _stack.pop_back();
}

cout<<"_stack size : "<<_stack.size()<<endl;

二、链栈：（c++实现）

#include <iostream>
using namespace std;

//链栈;
template <typename T>
class ListStack {
private:
    struct Node
    {
        T       data    ;           // 数据;
        Node*   pNext   ;           //下一个节点的指针;
    };

    Node*           m_pHead;        //头节点;
    int             m_iCount;       //节点数目;

public:
    //构造函数;
    ListStack()
    {
        m_iCount = 0;
        m_pHead = nullptr;
    }
    //析构函数;
    ~ListStack()
    {

    }

public:
    //判断空栈;
    bool isEmpty()
    {
        if (m_pHead == nullptr)
        {
            return true;
        }
        return false;
    }
    //向栈顶添加元素;
    bool push_back(T _element)
    {
        Node* pTemp = new Node();
        if (!pTemp)
        {
            return false;
        }
        pTemp->data = _element;
        pTemp->pNext = m_pHead;
        m_pHead = pTemp;
        m_iCount++;

        return true;
    }
    //删除栈顶元素;
    void pop_back()
    {
        if (!m_pHead)
        {
            return;
        }
        Node* pTemp = m_pHead;
        m_pHead = m_pHead->pNext;
        delete  pTemp;
        pTemp = nullptr;
        --m_iCount;
    }
    //获得栈中元素数量;
    const int& size()
    {
        return m_iCount;
    }
    //清空栈;
    void clear()
    {
        Node* pTemp = nullptr;
        while (m_pHead)
        {
            pTemp = m_pHead;
            m_pHead = m_pHead->pNext;
            delete pTemp;
            pTemp = nullptr;
            --m_iCount;
        }
    }
    //获得栈顶元素;
    const T&  getHeadElement()
    {
        if (!m_pHead)
        {
            cout<<"stack is empty! get head element fail!"<<endl;
            return NULL;
        }
        return m_pHead->data;
    }
};
//测试链栈;
ListStack<int> _stack;
    cout<<"_stack size:: "<<_stack.size()<<endl;

    _stack.pop_back();
    _stack.push_back(1);
    cout<<"_stack size : "<<_stack.size()<<"   "<<_stack.getHeadElement()<<endl;

    for (int j = 0; j<100; j++)
    {
        _stack.push_back(j);
    }

    cout<<"_stack size::"<<_stack.size()<<endl;

    int a[] = {1,3,24,58};
    int b[] = {100,302,33};
    ListStack<int*> _stack1;
    cout<<"_stack1 size:: "<<_stack1.size()<<endl;
    _stack1.push_back(a);
    _stack1.push_back(b);
    cout<<"_stack1 size: "<<_stack1.size()<<endl;
    _stack1.pop_back();
    cout<<"_stack1 size: "<<_stack1.size()<<endl;
    const  int*  p = _stack1.getHeadElement();
    for (int j = 0; j<4; j++)
    {
        cout<<" , "<<p[j]<<endl;
    }
    _stack1.pop_back();
    cout<<"_stack1 size:: "<<_stack1.size()<<endl;
    _stack1.push_back(a);
    _stack1.push_back(b);
    cout<<"_stack1 size:: "<<_stack1.size()<<endl;
    _stack1.clear();
    cout<<"_stack1 size:: "<<_stack1.size()<<endl;