数据结构_第三章_栈和队列

第三章 栈和队列

3.1特殊的线性表——栈
3.2特殊的线性表——队列

3.1特殊的线性表——栈

3.1.1栈的逻辑结构
栈：限定仅在表尾进行插入和删除操作的线性表。
空栈：不含任何数据元素的栈。
允许插入和删除的一端称为栈顶，另一端称为栈底。
栈的操作特性：后进先出。
3.1.2栈的顺序存储结构及实现
顺序栈类

//顺序栈类的声明
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;
}
//入栈
void  seqStack<T>::Push ( T  x)
{
     if (top==MAX_SIZE-1)  throw  “溢出”;
     top++;
     data[top]=x;
 } 
 //判断是否为空栈
bool  seqStack<T>::Empty ()
{
     if (top==-1)  
         return true;
     return false;
 } 
// 取栈顶
T  seqStack<T>::GetTop ( )
{
     if (Empty()) throw  ”空栈” ；
     return data[top];
 } 
 //出栈
T  seqStack<T>:: Pop ( )
{
     if (top==-1)  throw  “溢出”; 
     x=data[top];
      top--;
     return  x;
}

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

栈1的底固定在下标为0的一端；
栈2的底固定在下标为StackSize-1的一端；
top1和top2分别为栈1和栈2的栈顶指针；
Stack_Size为整个数组空间的大小。

两栈共享空间类

//两栈共享空间类的声明
const int Stack_Size=100;  
template <class T>
class BothStack 
{
  public:
       BothStack( );
       ~BothStack( ); 
       void Push(int i, T x);   
       T Pop(int i);          
       T GetTop(int i);       
       bool Empty(int i);     
  private:
       T data[Stack_Size];     
       int top1, top2;        
};
//输入
void BothStack<T>::Push(int i, T x )
{
    if (top1==top2-1) 
  throw "上溢";
    if (i==1) 
  data[++top1]=x;
    if (i==2) 
  data[--top2]=x;
}
//删除
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++]; 
   }
}
//判断某个栈为空
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;
    }
}
//取某个栈栈顶
T BothStack<T>::GetTop(int i)
{
    if(i==1) {
        if (top1!=-1)  return data[top1];
    }
    if(i==2) {
        if(top2!=StackSize)  return data[top2];
   } 
}

3.1.3栈的链接存储结构及实现
链栈：栈的链接存储结构
链栈类的实现

//链栈的类声明
template <class T>
class LinkStack
{    
   public:
         LinkStack( ) {top=NULL;};
         ~LinkStack( );            
         void Push(T x); 
         T Pop( ); 
         T GetTop( );
         bool Empty( );
   private:
         Node<T> *top; 
}
//插入
void LinkStack<T>::Push(T x)
{
    s=new Node<T>;
    s->data=x; 
    s->next=top; 
   top=s; 
}
//删除
T LinkStack<T>::Pop( )
{
    if (top==NULL)
     throw "下溢";
    x=top->data; 
    p=top; 
    top=top->next;   
    delete p;
    return x;
}
//链栈的析构
LinkStack<T>::~LinkStack( )
{
while (top)
 {
  Node<T> *p;
  p=top->next;
          delete top;
  top=p;
 }
}

顺序栈和链栈的比较
时间性能：相同，都是常数时间O(1)。
空间性能：
顺序栈：有元素个数的限制和空间浪费的问题。
链栈：没有栈满的问题，只有当内存没有可用空间时才会出现栈满，但是每个元素都需要一个指针域，从而产生了结构性开销。
结论：当栈的使用过程中元素个数变化较大时，用链栈是适宜的，反之，应该采用顺序栈。
3.2特殊线性表——队列
3.2.1 队列的逻辑结构
队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。
空队列：不含任何数据元素的队列。
允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。
队列的操作特性：先进先出(FIFO,LILO)。
队空：front=rear
队满：front=rear
为什么要将队空和队满的判定条件分开？
如何确定不同的队空、队满的判定条件？
方法一：附设一个存储队列中元素个数的变量num，当num=0时队空，当num=QueueSize时为队满；
方法二：修改队满条件，浪费一个元素空间，队满时数组中只有一个空闲单元；
方法三：设置标志flag，当front=rear且flag=0时为队空，当front=rear且flag=1时为队满。循环队列类

const int QueueSize=100; 
template <class T>    
class CirQueue{ 
  public:
      CirQueue( )； 
      ~ CirQueue( )；
      void EnQueue(T x); //入队
     T DeQueue( );//出队             
     T GetQueue( ); //读队头元素
     bool Empty( ){
      if (rear==front) return true;
       return false;
   }；
  private:
     T data[QueueSize];   
     int front, rear;
};

链队列类

template <class T>
class LinkQueue
{   
  public:
      LinkQueue( );     
      ~LinkQueue( );
      void EnQueue(T x);//入队
      T DeQueue( );    //出队 
      T GetQueue( )；  
      bool Empty( )；
  private:
      Node<T> *front, *rear;
};

循环队列和链队列的比较
时间性能:
循环队列和链队列的基本操作都需要常数时间O (1)。
空间性能:
循环队列：必须预先确定一个固定的长度，所以有存储元素个数的限制和空间浪费的问题。
链队列：没有队列满的问题，只有当内存没有可用空间时才会出现队列满，但是每个元素都需要一个指针域，从而产生了结构性开销。