栈的逻辑结构
栈：限定仅在表尾进行插入和删除操作的线性表。
空栈：不含任何数据元素的栈。
允许插入和删除的一端称为栈顶，另一端称为栈底。
栈的操作特性：后进先出。
注意：栈只是对表插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。
栈的顺序存储结构及实现
利用数组实现栈的顺序存储，确定用数组的哪一端表示栈底，附设指针top指示栈顶元素在数组中的位置。
进栈：top加1，出栈：top减1，栈空：top= -1，栈满：top= MAX_SIZE-1。
两栈共享空间(双端栈)
两栈共享空间：使用一个数组来存储两个栈，让一个栈的栈底为该数组的始端，另一个栈的栈底为该数组的末端，两个栈从各自的端点向中间延伸。
top1= -1时栈1为空，top2= Stack_Size时栈2为空，top1+1=top2时栈满。
栈的链接存储结构及实现
链栈：栈的链接存储结构。
将链头作为栈顶，方便操作，链栈不需要附设头结点。
链栈的实现——插入（入栈）
template <class T>
void LinkStack<T>::Push(T x)
{
s=new Node<T>;
s->data=x;
s->next=top;
top=s;
}
链栈的实现——删除（出栈）
template <class T>
T LinkStack<T>::Pop( )
{
if(top==NULL)
throw "下溢";
x=top->data;
p=top;
top=top->next;
delete p;
return x;
}
链栈的实现——链栈的析构（链栈的销毁）
template <class T>
LinkStack<T>::~LinkStack( )
{
while(top)
{
Node<T> *p;
p=top->next;
delete top;
top=p;
}
}
顺序栈和链栈的比较
时间性能：相同，都是常数时间O(1)。
空间性能：
顺序栈：有元素个数的限制和空间浪费的问题。
链栈：没有栈满的问题，只有当内存没有可用空间时才会出现栈满，但是每个元素都需要一个指针域，从而产生了结构性开销。
结论：当栈的使用过程中元素个数变化较大时，用链栈是适宜的，反之，应该采用顺序栈。
队列的逻辑结构
队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。
空队列：不含任何数据元素的队列。
允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。
队列的操作特性：先进先出(FIFO,LILO)
队列的顺序存储结构及实现
顺序队列：队列的顺序存储结构
设置队头、队尾两个指针，队头指针和队尾指针的说明：1、队头指针指向队列中的第一个元素之前的元素，队尾指针指向队列中的最后一个元素。2、队头指针指向队列中的第一个元素，队尾指针指向队列中的最后一个元素的后一个位置。
假溢出：当元素被插入到数组中下标最大的位置上之后，队列的空间就用尽了，尽管此时数组的低端还有空闲空间，这种现象叫做假溢出。
解决假溢出的方法：循环队列：将存储队列的数组头尾相接。
实现循环队列：
不存在物理的循环结构，用软件方法实现。
求模：rear=（rear＋1）% MAXSIZE
front=(front+1) % MAZSIZE
队空：front==rear
队满的条件：(rear+1) % QueueSize==front
循环队列的实现——入队
template <class T>
void CirQueue<T>::EnQueue(T x)
{
if ((rear+1) % QueueSize ==front) throw "上溢";
rear=(rear+1) % QueueSize;
data[rear]=x;
}
循环队列的实现——出队
template <class T>
T CirQueue<T>::DeQueue( )
{
if (rear==front) throw "下溢";
front=(front+1) % QueueSize;
return data[front];
}
循环队列的实现——读队头元素
template <class T>
T CirQueue<T>::GetQueue( )
{
if (rear==front) throw "下溢";
i=(front+1) % QueueSize;
return data[i];
}
循环队列的实现——队列长度
template <class T>
int CirQueue<T>::GetLength( )
{
if (rear==front) throw "下溢";
len=(rear-front+ QueueSize) % QueueSize;
return len;
}
队列的链接存储结构及实现
链队列：队列的链接存储结构
链队列的实现——构造函数
template <class T>
LinkQueue<T>::LinkQueue( )
{
front=new Node<T>;
front->next=NULL;
rear=front;
}
链队列的实现——入队
template <class T>
void LinkQueue<T>::EnQueue(T x)
{
s=new Node<T>;
s->data=x;
s->next=NULL;
rear->next=s;
rear=s;
}
链队列的实现——出队
template <class T>
T LinkQueue<T>::DeQueue( )
{
if (rear==front) throw "下溢";
p=front->next;
x=p->data;
front->next=p->next;
delete p;
if (front->next==NULL) rear=front;
return x;
}
循环队列和链队列的比较
时间性能: 循环队列和链队列的基本操作都需要常数时间O (1)。
空间性能:
循环队列：必须预先确定一个固定的长度，所以有存储元素个数的限制和空间浪费的问题。
链队列：没有队列满的问题，只有当内存没有可用空间时才会出现队列满，但是每个元素都需要一个指针域，从而产生了结构性开销。
