数据结构笔记：第三章 栈和队列

栈：限定仅在表尾进行插入和删除操作的线性表。

允许插入和删除的一端称为栈顶，另一端称为栈底。

设指针top指示栈顶元素在数组中的位置。    进栈：top加1    出栈：top减1     栈空：top=  -1     栈满：top=  MAX_SIZE-1

顺序栈类的声明 ：

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

两栈共享空间

两栈共享空间：栈1的底固定在下标为0的一端；

                         栈2的底固定在下标为StackSize-1的一端。

                         top1和top2分别为栈1和栈2的栈顶指针；

                         Stack_Size为整个数组空间的大小（图中用S表示）；

什么时候栈1为空？   top1= -1

什么时候栈2为空？   top2= 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;        
};

两栈共享空间的实现——插入：

1. 如果栈满，则抛出上溢异常；

2. 判断是插在栈1还是栈2；        

     2.1 若在栈1插入，则            

                2.1.1 top1加1;              

                2.1.2 在top1处填入x；      

     2.2 若在栈2插入，则              

              2.2.1 top2减1;            

             2.2.2 在top2处填入x；

template <class T> 
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;
}

两栈共享空间的实现——删除

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> 
T BothStack<T>::GetTop(int i)
{
    if(i==1)	{
        if (top1!=-1) 	return data[top1];
    }
    if(i==2)	{
        if(top2!=StackSize)  return data[top2];
   } 
}

链 栈 的 类 声 明：

template <class T>
class LinkStack
{    
   public:
         LinkStack( ) {top=NULL;};
         ~LinkStack( );            
         void Push(T x); 
         T Pop( ); 
         T GetTop( );
         bool Empty( );
   private:
         Node<T> *top; 
}

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

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

 

 

 

队列

队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。

允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。 

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

循环时：rear=（rear＋1）% MAXSIZE               front=(front+1) % MAZSIZE

队满的条件：(rear+1) mod QueueSize==front

循 环 队 列 类 的 声 明：

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>
 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>
class LinkQueue
{   
  public:
      LinkQueue( );     
      ~LinkQueue( ); 
      void EnQueue(T x);
      T DeQueue( );       
      T GetQueue( )；
      bool Empty( )；
  private:
      Node<T> *front, *rear;
};

链队列的实现——构造函数：

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