数据结构：线性表（栈和队列）

1、栈和队列

（1）栈

• 只能在表的一端（栈顶）进行插入和删除运算的线性表
• 是一种插入和删除只能在“端点”进行的线性表，栈只能在栈顶运算，且访问结点时依照后进先出（LIFO）或先进后出（FILO）的原则（叠盘子）

（2）队列

• 只能在表的一端（队尾）进行插入，在另一端（队头）进行删除运算的线性表
• 先进先出（FIFO）例如：排队

（3）运算规则

• 顺序表：随机
• 链表：顺序存取
• 栈：后进先出
• 队列：先进先出

2、顺序栈

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

• 判断是否空栈，若空则返回错误
• 否则通过栈顶指针获取栈顶元素

3、链栈

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

4、队列的顺序表示

（1）定义

#define M  100   //最大队列长度
Typedef struct {
   QElemType *base;  //初始化的动态分配存储空间
   int  front;            //头指针   
   int  rear;             //尾指针
}SqQueue;  

5、循环队列

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

6、链队列

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