棧的實現c++

這兩天學習了棧和隊列，其實它們都是特殊的的線性表，只是對它的刪除和插入操作做了限定。

 棧是僅在表尾（棧頂）進行插入和刪除操作，遵從先進后出的規則。它的一些應用，像是文檔編輯器中的撤銷操作，網頁的后退操作，還有編輯器的對遞歸函數的處理，和四則運算表達式求值都用到了棧這樣的數據結構。

這里分順序和鏈式兩種方式實現：

1.順序存儲結構：

缺陷是要先確定數組存儲的大小，否則，還得擴容，比較麻煩。。

頭文件，聲明和定義放一塊了

 

#ifndef STACK1_H
#define STACK1_H
#include <iostream>
using namespace std;
template<typename T>
class Stack
{
public:
      Stack(int size);
    ~Stack();

    void push(const T& node);  //插入操作
    void pop();  //彈出操作
     T top();    //返回棧頂元素

    int size()const;
    bool empty() const;
    void clear();

 //此處是棧的順序存儲結構
private:
    T  *data;
    int Top;      //棧頂指針
    int MAXSIZE;
};
//空棧時top為-1，一個元素為0
template<typename T>
Stack<T>::Stack(int size=100) :Top(-1),MAXSIZE(size)
{
    data=new T[size];
}

template<typename T>                  //對棧分配的空間調用析構函數
Stack<T>::~Stack()
{
     clear();
     delete [ ]data;
}
template<typename T>
 void Stack<T>:: clear()                       //對棧里面的元素調用元素對象的析構函數
{
     while(Top!=-1)
        data[Top--].~T();
}

template<typename T>
void Stack<T>::push(const T& value)
{
    if(Top==MAXSIZE-1)
   {
        cerr<<"棧已經滿"<<endl;
       return ;                                      //可以像vector的函數reserve一樣擴容，此處略
    }
       data[++Top]= value;
}

template<typename T>
T Stack<T>::top()
{
    if (empty())
    {
          cerr<<"Error, stack is empty!";
    }
    return data[Top];
}

template<typename T>
void Stack<T>::pop()
{
    if (empty())
    {
          cerr<<"Error, stack is empty!";
          return;
    }
   Top-- ;                      //或者data[Top--].~T();每彈出一個就析構一個元素
}

template<typename T>
bool Stack<T>::empty() const
{
    return Top ==-1;
}

template<typename T>
int Stack<T>::size()const
{
    return Top+1;
}

#endif // STACK1_H

 

 

測試主程序：

#include <iostream>
#include "Stack1.h"
using namespace std;


int main ()
{
        Stack<int> s(10);
        for(int i = 0; i < 10; ++i)
        {
            s.push(i);
        }
        for(int j = s.size()-1 ; j >= 0; --j)
        {
            cout<< "node: " << s.top() <<endl;
            s.pop();
        }

       cout<<s.size();
       return 0;
}

 

 

2.鏈式存儲結構：

頭文件：

 

#ifndef STACK_H
#define STACK_H
#include <iostream>
using namespace std;

template<typename T>
class Stack
{
public:
      Stack();
    ~Stack();

    void push(const T& node);  //插入操作
    void pop();  //彈出操作
     T top();    //返回棧頂元素

    int size()const;
    bool empty() const;
    void clear();

 //此處是棧的鏈式存儲結構
private:
    struct StackNode
    {
        T data;
        StackNode* next;
        StackNode(const T& Newdata, StackNode* nextNode)
            :data(Newdata),next(nextNode)
        { }
    };
    StackNode * Top;   //棧頂指針
    int count;
    // 防止默認拷貝和默認賦值
    Stack(const Stack& rhs);
    Stack& operator=(const Stack& rhs);

};
template<typename T>
Stack<T>::Stack()
    :Top(NULL),count(0){}

template<typename T>
Stack<T>::~Stack()
{
    clear();
}
template<typename T>
void Stack<T>::push(const T& node)
{
    Top = new StackNode(node,Top);
    count ++;
}

template<typename T>
T Stack<T>::top()
{
    if (empty())
    {
          cerr<<"Error, stack is empty!";
    }
    return Top->data;
}

template<typename T>
void Stack<T>::pop()
{
    if (empty())
    {
          cerr<<"Error, stack is empty!";
    }
    StackNode* stackTop= Top;
   Top = Top->next;
    delete stackTop;
    count--;
}

template<typename T>
bool Stack<T>::empty() const
{
    return Top ==NULL;
}

template<typename T>
void Stack<T>::clear()
{
    while (Top)
    {
        StackNode* stackTop = Top;
       Top = Top->next;
        delete stackTop;
    }
   count = 0;
}
template<typename T>
int Stack<T>::size()const
{
    return count;
}
#endif // STACK_H

 

主程序：

#include <iostream>
#include "Stack.h"
using namespace std;


int main ()
{
        Stack<int> s;
        for(int i = 0; i < 10; ++i)
        {
            s.push(i);
        }
        for(int j = s.size()-1 ; j >= 0; --j)
        {
            cout<< "node: " << s.top() <<endl;
            s.pop();
        }

        s.clear();
       cout<<s.size();
       return 0;
}