特殊线性表–栈和队列

顺序栈——栈的顺序存储结构

栈属于特殊的线性表,支持进栈出栈判空判满等基础操作.
可以利用数组模拟栈搭配top值进行以上的基础操作.
两栈共享空间(双端栈) :
在一个程序中需要同时使用具有相同数据类型的两个栈,可以为这两个栈用数组模拟创建共享空间,称为双向栈.
两栈共享空间：使用一个数组来存储两个栈，让一个栈的栈底为该数组的始端，另一个栈的栈底为该数组的末端，两个栈从各自的端点向中间延伸。
插入:

 if (top1==top2-1) 
		throw "上溢";
    if (i==1) 
		data[++top1]=x;
    if (i==2) 
		data[--top2]=x;

栈的链式存储结构及实现

将链头作为栈顶，方便操作。链栈不需要附设头结点。

链栈的实现——插入（入栈）

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

顺序栈和链栈的比较:
时间性能:相同，都是常数时间O(1)。
空间性能：
顺序栈：有元素个数的限制和空间浪费的问题。
链栈：没有栈满的问题，只有当内存没有可用空间时才会出现栈满，但是每个元素都需要一个指针域，从而产生了结构性开销。
结论：
当栈的使用过程中元素个数变化较大时，用链栈是适宜的，反之，应该采用顺序栈。

队列的顺序存储结构及实现

通常情况下，队首元素存放在下标为0的一端.
利用数组实现队列的顺序存储,出队操作时间性能为O(n):

改进出队的时间性能:
放宽队列的所有元素必须存储在数组的前n个单元这一条件 ，只要求队列的元素存储在数组中连续的位置。
设置队头、队尾两个指针,队头指针指向队头元素的前一个位置,队尾指针指向队中最后一个元素

1.队头指针指向队列中的第一个元素之前的元素，队尾指针指向队列中的最后一个元素
2.队头指针指向队列中的第一个元素，队尾指针指向队列中的最后一个元素的后一个位置

入队操作时间性能仍为O(1), 出队操作时间性能提高为O(1).

但是这样操作可能会存在假溢出现象:
假溢出：当元素被插入到数组中下标最大的位置上之后，队列的空间就用尽了，尽管此时数组的低端还有空闲空间，这种现象叫做假溢出。

解决假溢出:
循环队列：将存储队列的数组头尾相接。
不存在物理的循环结构，用求模方法实现:
求模：

rear=（rear＋1）% MAXSIZE
front=(front+1) % MAZSIZE

队列顺序存储操作:
修改队满条件，浪费一个元素空间，队满时数组中只有一个空闲单元；

T data[QueueSize];   
int front, rear;

判空:

bool Empty( ){
   
  if (rear==front) return true;
  return false;
}；

队满的条件：(rear+1) mod 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];
}

求队列长度:

(rear-front+QueueSize)%Queuesize

if (rear==front) throw "下溢"; 
    len=(rear-front+ QueueSize) % QueueSize;  
    return len;

队列的链式存储结构及实现:

链式队列的出队:

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)。
空间性能:
循环队列：必须预先确定一个固定的长度，所以有存储元素个数的限制和空间浪费的问题。
链队列：没有队列满的问题，只有当内存没有可用空间时才会出现队列满，但是每个元素都需要一个指针域，从而产生了结构性开销。