在這裡我們接下來實現兩個資料結構，一個是stack，一個是queue

stack和queue資料特性？

毫無疑問，我想每一個學過資料結構的人都可以脫口而出，棧的資料特性採用的是先進後出，而佇列採用的時候先進先出。

stack和queue採用什麼型別的資料結構？

我們來這樣思考，對於棧來說，我們最多需要操作的是棧頂，如果我們採用鏈式的方式，就需要從頭一直遍歷到尾部，然後才能再次進行維護。而如果我們採用順序的結構，直接可以通過索引來進行訪問，效率會更高。所以對於棧來說我們採用順序的儲存方式最好的。

然後一個問題是對於佇列，我們對佇列採用最多的是頭刪和尾插，這就類似於list操作當中的pushback和popfront，維護起來方便，而對於順序儲存方式，如果我們要頭刪，我們需要把所以後面的元素都向前移動，這樣效率會降低。

瞭解了我們所需要採取的資料結構型別以後，剩下的就簡單了，和以前利用模板實現連結串列和順序表類似，進行寫程式碼。

示例程式碼：

stacak.h

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<cstdlib>
#include<cassert>
using namespace std;
template<typename T>
class Stack
{
public:
    Stack()
        :_pdata(NULL)
        , _sz
 
(0)
        , _capacity(0)
    {

    }
    void Push(const T& d)
    {
        CheckCapacity();
        _pdata[_sz++] = d;
    }
    void Pop()
    {
        assert(_sz > 0);
        _sz--;
    }
    T Top()
    {
        assert(_sz > 0);
        return _pdata[_sz-1];
    }
    size_t Size()
    {
        return
 
 _sz;
    }
    bool Empty()
    {
        if (_sz == 0)
            return true;
        else
            return false;
    }
protected:
    void CheckCapacity()
    {
        if (_sz == _capacity)
        {
            size_t NewCapacity = _capacity * 2 + 1;
            T* Temp = new T[NewCapacity];
            //在這裡需要注意考慮自定義型別和內建型別的區別，保險期間，我採用下面的方式，另外的解決方法是——型別萃取
            for (size_t i = 0; i < _sz; i++)
            {
                Temp[i] = _pdata[i];
            }
            delete _pdata;
            _pdata = Temp;
            _capacity = NewCapacity;
        }
    }
protected:
    T * _pdata;
    size_t _sz;
    size_t _capacity;
};

queue.h

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<cstdlib>
#include<cassert>

using namespace std;
template <typename T>
struct QueueNode
{
public:
    QueueNode()
        :_next(NULL)
        , data(0)
    {}

    QueueNode *_next;
    T data;
};
template<typename T>
class Queue
{
public:
    Queue()
        :_head(NULL)
        , _tail(NULL)
    {}
    ~Queue()
    {
        QueueNode<T>* cur = _head;
        while (cur != NULL)
        {
            QueueNode<T>* del=cur;
            cur = cur->_next;
            delete del;
            del = NULL;
        }
    }
    bool empty()
    {
        if (_head == NULL)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    size_t size()
    {
        size_t count(0);
        QueueNode<T> *cur = _head;
        while (cur != NULL)
        {
            count++;
            cur = cur->_next;
        }
        return count;
    }
    T& front()
    {
        assert(_head != NULL); 
        return _head->data;
    }
    T& back()
    {   
        assert(_tail != NULL);
        return _tail->data;
    }
    void push(const T& d)
    {
        if (_head == NULL)
        {
            _head = new QueueNode<T>;
            _head->data = d;
            _tail = _head;
        }
        else
        {
            QueueNode<T> *tmp = new QueueNode <T>;
            tmp->data = d;
            tmp->_next = NULL;
            _tail->_next = tmp;
            _tail = _tail->_next;
        }
    }
    void pop()
    {
        assert(_head != NULL);
        QueueNode<T> *del = _head;
        _head = _head->_next;
        delete del;
        del = NULL;

    }
protected:
    QueueNode<T>* _head;
    QueueNode<T>* _tail;
};

記得注意模板的書寫