數據結構：線性表（棧和隊列）

一、棧和隊列

（1）棧

• 只能在表的一端（棧頂）進行插入和刪除運算的線性表
• 是一種插入和刪除只能在「端點」進行的線性表，棧只能在棧頂運算，且訪問結點時依照後進先出（LIFO）或先進後出（FILO）的原則（疊盤子）

（2）隊列

• 只能在表的一端（隊尾）進行插入，在另外一端（隊頭）進行刪除運算的線性表
• 先進先出（FIFO）例如：排隊

（3）運算規則

• 順序表：隨機
• 鏈表：順序存取
• 棧：後進先出
• 隊列：先進先出

 

二、順序棧

（1）順序棧的表示

#define  MAXSIZE  100
typedef struct
{
        SElemType   *base;
        SElemType   *top;
        int stacksize;
}SqStack;

（2）初始化

Status InitStack( SqStack &S )
{
    S.base =new SElemType[MAXSIZE]；
    if( !S.base )     return OVERFLOW;
    S.top = S.base;
    S.stackSize = MAXSIZE;
    return OK;
}

分配空間並檢查空間是否分配失敗，若失敗則返回錯誤

設置棧底和棧頂指針：S.top = S.base;

設置大小

（3）判斷是否爲空

bool StackEmpty( SqStack S )
{
    if(S.top == S.base) return true;
   else return false;
}

（4）長度

int StackLength( SqStack S )
{
    return S.top – S.base;
}

（5）清空

Status ClearStack( SqStack S )
{
    if( S.base ) S.top = S.base;
    return OK;
}

（6）銷燬

Status DestroyStack( SqStack &S )
{
    if( S.base )
    {
        delete S.base ;
        S.stacksize = 0;
        S.base = S.top = NULL;
    }
  return OK;
}

（7）進棧

Status Push( SqStack &S, SElemType e)  
{
    if( S.top - S.base== S.stacksize ) // 棧滿
        return ERROR;     
    *S.top++=e;
    return OK;
}

• 判斷是否棧滿，若滿則出錯
• 元素e壓入棧頂
• 棧頂指針加1

（8）出棧

Status Pop( SqStack &S, SElemType &e)  
{
    if( S.top == S.base ) // 棧空
        return ERROR;     
    e＝ *--S.top;
    return OK;
}

• 判斷是否棧空，若空則出錯
• 獲取棧頂元素e
• 棧頂指針減1

（9）取棧頂元素

Status GetTop( SqStack S, SElemType &e)  
{
    if( S.top == S.base )     return ERROR;     // 棧空
    e = *( S.top – 1 );
    return OK;
}

• 判斷是否空棧，若空則返回錯誤
• 不然經過棧頂指針獲取棧頂元素

 

三、鏈棧

（1）鏈棧的表示

typedef  struct StackNode {
      SElemType  data;
      struct StackNode *next;
 } StackNode,  *LinkStack;
LinkStack S;   

（2）初始化

void InitStack(LinkStack &S )
{
    S=NULL;
}

（3）判斷是否爲空

Status StackEmpty(LinkStack S){
 if (S==NULL) return TRUE;
  else return FALSE;
}

（4）進棧

Status Push(LinkStack &S , SElemType e){
    p=new StackNode;      //生成新結點p 
    if (!p) exit(OVERFLOW);
    p->data=e;
    p->next=S; 
    S=p; 
    return OK; 
}

（5）出棧

Status Pop (LinkStack &S,SElemType &e)
{
if (S==NULL) return ERROR;
 e = S-> data;  p = S;   S =  S-> next;
 delete p;   return OK;
  }  

（6）取棧頂元素

Teletype GetTop(LinkStack S)
   {
       if (S==NULL) exit(1)；
       else return S–>data;
    }

 

四、隊列的順序表示

（1）定義

#define M  100   //最大隊列長度
Typedef struct {
   QElemType *base;  //初始化的動態分配存儲空間
   int  front;            //頭指針   
   int  rear;             //尾指針
}SqQueue;  

 

五、循環隊列

（1）定義

#define MAXQSIZE  100  //最大長度
Typedef struct {
   QElemType *base;  //初始化的動態分配存儲空間
   int  front;            //頭指針   
   int  rear;             //尾指針
}SqQueue;  

（2）初始化

Status InitQueue (SqQueue &Q){
    Q.base =new QElemType[MAXQSIZE] 
   if(!Q.base) exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}

（3）長度

int  QueueLength (SqQueue Q){
    return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;                             
 }

（4）入隊

Status EnQueue(SqQueue &Q,QElemType e){
    if((Q.rear+1)%MAXQSIZE==Q.front)  return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
     return OK;
}

（5）出隊

Status DeQueue (LinkQueue &Q,QElemType &e){
   if(Q.front==Q.rear) return ERROR;
   e=Q.base[Q.front];
   Q.front=(Q.front+1)%MAXQSIZE;
   return OK;
}

 

六、鏈隊列

（1）定義

typedef struct QNode{
   QElemType   data;
   struct Qnode  *next;
}Qnode, *QueuePtr;
typedef struct {
   QueuePtr  front;            //隊頭指針   
   QueuePtr  rear;             //隊尾指針
}LinkQueue;  

（2）初始化

Status InitQueue (LinkQueue &Q){
   Q.front=Q.rear=(QueuePtr) malloc(sizeof(QNode)); 
    if(!Q.front) exit(OVERFLOW);
    Q.front->next=NULL;
     return OK;
}

（3）銷燬

Status DestroyQueue (LinkQueue &Q){
   while(Q.front){
      Q.rear=Q.front->next;
      free(Q.front);
      Q.front=Q.rear;   }    
   return OK;
}

（4）是否爲空

Status QueueEmpty (LinkQueue Q)
{
    return (Q.front==Q.rear);                             
 }

（5）求隊頭元素

Status GetHead (LinkQueue Q, QElemType &e){
   if(Q.front==Q.rear) return ERROR;
   e=Q.front->next->data;
   return OK;
}

（6）入隊

Status EnQueue(LinkQueue &Q,QElemType e){
    p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) exit(OVERFLOW);
    p->data=e; p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}

（7）出隊

Status DeQueue (LinkQueue &Q,QElemType &e){
   if(Q.front==Q.rear) return ERROR;
   p=Q.front->next;
   e=p->data;
   Q.front->next=p->next;
   if(Q.rear==p) Q.rear=Q.front;
   delete p;
   return OK;
}