数据结构笔记-3（栈和队列）

栈

一.栈的逻辑结构

栈：限定仅在表尾进行插入和删除操作的线性表。
空栈：不含任何数据元素的栈。
允许插入和删除的一端称为栈顶，另一端称为栈底。

二.栈的顺序存储结构及实现

顺序栈类的声明：

const  int  MAX_SIZE=100;
template  <class T>
class  seqStack
{
    public:
        seqStack ( ) ;
        ~seqStack ( );
        void  Push ( T  x );
        T   Pop ( );
        T   GetTop ( );
        bool  Empty ( );
    private:
        T  data[MAX_SIZE];
        int  top;
}

入栈：

template <class T>
void  seqStack<T>::Push ( T  x)
{
     if (top==MAX_SIZE-1)  throw  “溢出”;
     top++;
     data[top]=x;
 } 

判断是否为空栈：

template <class T>
bool  seqStack<T>::Empty ()
{
     if (top==-1)  
         return true;
     return false;
 } 

取栈顶：

template <class T>
T  seqStack<T>::GetTop ( )
{
     if (Empty()) throw  ”空栈” ；
     return data[top];
 } 

出栈：

template  <class  T>
T  seqStack<T>:: Pop ( )
{
     if (top==-1)  throw  “溢出”; 
     x=data[top];
      top--;
     return  x;
}

两栈共享空间

使用一个数组来存储两个栈，让一个栈的栈底为该数组的始端，另一个栈的栈底为该数组的末端，两个栈从各自的端点向中间延伸。
插入:

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

删除：

template <class T>
T BothStack<T>::Pop(int i){
    if (i==1) {   
        if (top1== -1) 	throw "下溢";
        return data[top1--];
    }
    if (i==2) {                           
        if (top2==StackSize)  	throw "下溢";
        return data[top2++]; 
   }
}

判断栈空：

template <class T> 
bool BothStack<T>::Empty(int i)
{  
    if(i==1){
        if(top1==-1) 	return 1;
        else 	return 0;
    }
    if(i==2)	{
        if(top2==StackSize)	return 1;
        else  return 0;
    }
}

取栈顶：

template <class T> 
T BothStack<T>::GetTop(int i)
{
    if(i==1)	{
        if (top1!=-1) 	return data[top1];
    }
    if(i==2)	{
        if(top2!=StackSize)  return data[top2];
   } 
}

顺序栈和链栈的比较:

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

队列

队列的操作特性：先进先出

队列顺序结构及实现

判断队空：front == rear
判断队满：(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];
}