栈和队列

栈的定义–Stack
栈是只允许在末端进行插入和删除的线性表。栈具有后进先出的特性（LIFO，Last In First Out）。

栈的应用
1.算术表达式求值。波兰表达式（后缀表达式）
2.迷宫问题
3.栈模拟压栈，实现递归转非递归。

#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;
};

队列的定义
队列只允许在表的队尾进行插入，在表队头进行删除。队列具有先进先出的特性。（FIFO，first In First Out）

优先级队列的定义
每次从队列中取出的都应是最高优先级的数据，这种队列就是优先级队列。 –后续使用Heap实现

队列的应用
1. 生产者消费者模型，如网络数据buffer
2. 任务队列
3. 图的广度优先遍历

#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);

    // O(N^2)
    // N N-1 N-2 ...1
    //while(q.Size() > 0)
    while(!q.Empty())
    {
        //cout<<q.Front()<<" ";
        q.Pop();
    }
    cout<<endl;
}