栈与队列

一、栈是限定仅在表尾进行插入和删除的线性表
允许插入和删除的一端称为栈顶，另一端称为栈底，栈又称为先进后出的线性表简称LIFO结构

栈的抽象数据类型
ADT 栈
Data
同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系
Operation
InitStack(*S):初始化操作，建立一个空栈S。
DestroyStack(*S):若栈存在，则销毁它。
ClearStack(*S):将栈清空
StackEmpty(S):若栈为空，返回true，否则返回false。
GetTop(S,*e):若栈存在且非空，用e返回S的栈顶元素。
Push(*S,e):若栈S存在，插入新元素e到栈S中并成为栈顶元素。
Pop(*S,*e):删除栈S中栈顶元素，并用e返回其值。
StackLength(S):返回栈S的元素个数。
endADT

栈的结构定义

typedef int SElemType;typedef struct{    SElemType data[MAXSIZE];    int top;}SqStack;

1、进栈操作

Status Push(SqStack *S,SElemType e){    if(S->top==MAXSIZE-1){        return ERROR;    }    S->top++;    S->data[S->top]=e;    return OK;}

2、出栈操作

Status Pop(SqStack *S,SElemType *e){    if(S->top ==-1){        return ERROR;    }    *e=S->data[S->top];    S->top--;    return OK;}

栈的链表存储结构

typedef struct StackNode{    SElemType data;    struct StackNode *next;}StackNode,*LinkStackPtr;typedef struct LinkStack{    LinkStackPtr top;    int count;}LinkStack;

1、进栈操作

Status Push(LinkStack *S,SElemType e){    LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));    s->data =e;    s->next = S->top;    S->top=s;    S->count++;    return OK;}

2、出栈操作

Status Pop(LinkStack *S,SElemType *e){    LinkStackPtr p;    if(StackEmpty(*S))     return ERROR;    *e = S->top->data;    p=S->top;     S->top =S->top->next;    free(p);    S->count--;    return OK;}

二、队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出的线性表简称FIFO。

队列的抽象数据类型

ADT 队列

Data
同线性表，元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
InitQueue(*Q):初始化操作，建立一个空队列Q
DestroyQueue(*Q):若队列Q存在，则销毁它。
ClearQueue(*Q):将队列Q清空
QueueEmpty（Q）:若队列Q为空，返回true，否则返回false。
GetHead(Q,*e):若队列Q存在，用e返回队列Q的队头元素
EnQueue(*Q,e):若队列Q存在，插入新元素e到队列Q中并成为队尾元素。
DeQueue(*Q,*e):删除队列Q中队头元素，并用e返回其值。
QueueLength(Q):返回队列Q的元素个数。
endADT
循环队列的顺序存储结构

typedef int QElemType;typedef struct{    QElemType data[MAXSIZE];    int front;    int rear;}SqQueue;

循环队列的初始化

Status InitQueue(SqQueue *Q){    Q->front =0;    Q->rear =0;    return OK;}

循环队列长度：

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

入队操作

Status EnQueue(SqQueue *Q,QElemType e){    if((Q->rear+1)%MAXSIZE==Q->front)        return OK;    Q->data[Q->rear]=e;    Q->rear=(Q->rear+1)%MAXSIZE;    return OK:}

出队

Status DeQueue(SqQueue *Q,QElemType *e){    if(Q->front == Q->rear)        return ERROR;    *e=Q->data[Q->front];    Q->front = (Q->front+1)%MAXSIZE;    return OK;}

队列的链式存储
链队列结构

typedef int QElemType;typedef struct QNode{    QEleType data;    struct　QNode *next;}QNode,*QueuePtr;typedef struct{    QueuePtr front,rear;}LinkQueue;

入队

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

出队

Status DeQueue(LinkQueue *Q,QElemType *e){    QueuePtr p;    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;    free(p);    return OK;}