首先我们来看一下基本实现栈
#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;
}