用数组和链表分别实现栈类stack，队queue

栈(stack)是一种常见数据结构，以后进先出(LIFO)著称。比如编译器用栈处理函数调用，保存被调用函数的参数和局部变量。当一个函数调用另一个函数时候，新的函数参数和局部变量被入栈。调用结束，占用的资源从栈释放。

用数组实现：

class vector{
private:
T *ele;
int size;
int cap;
public:
vector<T>(){size=0;cap=16;ele=new T[cap];}
void sure(){if(size>cap) {T*old=ele;
cap=2*size;
ele=new T[cap];
for(int i=0;i<size;i++)
ele[i]=old[i];
delete old;}
}
void push_back(T x);
void pop_back();
int size1();
T at(int index);
bool empty();
void clear();
void swap(vector<T> &v1);};
template<typename T>
void vector<T>::push_back(T x){
sure();
ele[size++]=x;}
template<typename T>
void vector<T>::pop_back(){
if(empty()) throw runtime_error("empty");
--size;}
template<typename T>
int vector<T>::size1(){
return size;}
template<typename T>
T vector<T>::at(int index){
if(empty()||index>cap) throw runtime_error("empty");
return ele[index];}
template<typename T>
bool vector<T>::empty(){
if(size==0) return true;
else return false;}
template<typename T>
void vector<T>::clear(){
while(!empty()){
pop_back();}
}
template<typename T>
void vector<T>::swap(vector<T> &v1){
int len=v1.size1();
if(len>=size){
T *p=new T[len];
for(int i=0;i<size;i++)
{p[i]=ele[i];}
clear();
for(int i=0;i<len;i++)
push_back(v1.at(i));
v1.clear();
for(int i=0;i<len;i++)
{v1.push_back(p[i]);}}
else{
T *p=new T[size];
for(int i=0;i<size;i++)
{p[i]=ele[i];}
clear();
for(int i=0;i<len;i++)
{ele[i]=v1.at(i);}
v1.clear();
for(int i=0;i<size;i++)
{v1.push_back(p[i]);}
}
}

用栈实现：

#include"15.h"//包含linklist类定义
using namespace std;
template<typename T>
class stack1{
private:
linklist<T> li;
public:
stack1();
bool isempty();
T peek();
void push(T val);
T pop();
int getsize1();};

//define
template<typename T>
stack1::stack1(){}
template<typename T>
bool stack1<T>::isempty(){
return li.empty();}
template<typename T>
T satck1<T>::peek(){
if(isempty()) throw runtime_error("empty");
return li.getlast();}
template<typename T>
void stack1<T>::push(T val){
li.addlast(val);}
template<typename T>
T stack1<T>::pop(){
return li.removelast();}
template<typename T>
int stack1<T>::getsize1(){
return li.getsize();}

可以发现，定义好链表类Linklist后，实现其他的数据结构比如：stack类非常简单，常见的就是根据stack类LIFO准则在链表尾部各种操作即可。stack类的接口（各种成员函数和构造函数不变）,只是具体实现是链表而不是数组。这也侧面体现了封装的好处，使用者只需考虑接口如何使用，内部任便何种实现!

由此可以得到启发，用链表实现队的实现，与stack的LIFO不同，queue是FIFO机制，根据此类机制实现：

template<typename T>
class queue{
private:
linklist<T> list;
public:
queue(){}
void enqueue(T val);
T dequeue();
int getsize();};
template<typename T>
void queue<T>::enqueue(T val){
list.addlast(val);}
template<typename T>
T queue<T>::dequeue(){
return list.removefirst();}
template<typename T>
int queue<T>::getsize(){
return list.getsize();}