实现基本栈和队列

首先我们来看一下基本实现栈

#pragma once

// 静态栈
//template<class T, size_t N = 100>
//class Stack
//{
//public:
//  void Push(const T& x)
//  {
//      if (_size == N)
//      {
//          throw out_of_range("stack is full");
//      }
//
//      _a[_size++] = x;
//  }
//
//  void Pop()
//  {
//      assert(_size > 0);
//      --_size;
//  }
//
//  T& Top()
//  {
//      return _a[_size-1];
//  }
//protected:
//  T _a[N];
//  size_t _size;
//};

template<class T>
class Stack()
{
public:
    Stack()
        :_a(NULL)
        ,_size(0)
        ,_capacity(0)
    {}

    void Push(const T& x)
    {
        CheckCapacity();

        _a[_size++] = x;
    }

    void Pop()
    {
        assert(_size > 0);
        --_size;
    }

    T& Top()
    {
        assert(_size > 0);
        return _a[_size-1];
    }

    void CheckCapacity()
    {
        if (_size >= _capacity)
        {
            _capacity = _capacity*2+3;
            T* tmp = new T[_capacity];
            if (_a)
            {
                for (size_t i = 0; i < _size; ++i)
                    tmp[i] = _a[i];

                delete[] _a;
                _a = tmp;
            }
        }
    }

protected:
    T* _a;
    size_t _size;
    size_t _capacity;
};

接下来是队列

#pragma once

template<class T>
struct QueueNode()
{
   T _data;
   QueueNode<T>* _next;
}
#include <class T>
class Queue
{
    typedef QueueNode<T> Node;
public:
    Queue()
        ;_head(NULL)
        ,_tail(NULL)
    {}

    void Push(const T& x)
    {
        if(_head == NULL)
        {
            _head = _tail = new Node(x);
        }
        else
        {
            _tail->_next = new Node(x);
            _tail = _tail->_next;
        }
    }

    void Pop()
    {
        if(_head == NULL)
        {
            return;
        }
        else if(_head == _tail)
        {
            delete _head;
            _head = _tail = NULL;
        }
        else
        {
            Node* next = _head->_next;
            delete _head;
            _head = next;
        }
    }

    bool Empty()
    {
        return _head == NULL;
    }

    size_t size()
    {
        size_t size = 0;
        Node* cur = _head;
        while(cur)
        {
            ++size;
            cur = cur->_next;
        }
        return size;
    }
protected:
    Node* _head;
    Node* _tail;
};

void TestQueue()
{
    Queue<int> q;
    q.Push(1);
    q.Push(2);
    q.Push(3);
    q.Push(4);
    while(!q.Empty())
    {
        q.Pop();
    }
    cout<<endl;
}