栈和队列（思想+伪代码+部分代码）

ADT 栈（stack）

Data

同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。

operation

InitStack(*s):初始化操作，建立一个空栈S。

DestroyStack(*s):若栈存在，则销毁它。

ClearStack(*s):将栈清空。

StackEmpty(s):若栈为空，返回ture，否则，返回flash

GetTop(s,*e):若栈不空，用e返回s的栈顶元素

Push(*s,e):插入e到栈s中并成为栈顶元素

Pop(*s,e):删除栈顶元素，并用e返回其值

StackLength(s):返回栈s的元素个数

endADT

ADT 队列( queue)

队列(只允许在一端进行插入操作，另一端进行删除操作的线性表，先进先出)

允许插入的一端是队尾，允许删除的一端是队头

ADT 队列(queue)

data

同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系

operation

InitQueue(*Q):初始化操作，创建一个空队列Q

DeatroyQueue(*Q):若队列Q存在，则销毁它

ClearQueue(*Q):将队列清空

QueueEmpty(Q):若队列为空，则返回ture，否则，返回false

GetHead(Q,*e):若队列存在且非空，用e返回队列Q的队头元素

EnQueue(*Q,e):若队列存在，插入新元素e到队列Q中并成为队尾元素

DeQueue(*Q,*e):删除队列Q中队头元素，并用e返回其值

QueueLength(Q):返回队列Q的元素个数

endADT

*栈的结构定义

typedef int SElemType;//类型定义根据实际情况而定，这里假设为int
typedef struct
{
SElemType data[MAXSIZE];
int top;//用于栈顶指针
}sqStack;

栈的存储结构

/*插入元素e为新的栈顶元素(push)*/
Status Push(SqStack *s,SElemType e)
{
if(s->top==MAXSIZE-1)//栈满
{
return ERROR;
}
s->top++;//栈顶指针加1
s->data[s->top]=e;//将新插入元素赋值给栈顶空间
return OK;
}

出栈pop

/*若栈不空，则删除s的栈顶元素，并用e返回其值，并返回OK,否则返回ERROR;*/

status Pop(SqStack *s,SElemType *e)
{
if(s->top==-1)
return ERROR;//将要删除的栈顶元素赋值给e
*e=s->data[s->top];//栈顶指针减1
s->top--;
return OK;
}

/*两栈共享空间结构*/

typedef struct
{
SElemType data[MAXSIZE];
int top1;//栈1栈顶指针
int top2;//栈2栈顶指针
}SqDoubleStack;

/*插入元素e为新的栈顶元素*/

Status push(SqDoubleStack *s,SElemType e,int stackNumber)
{
if(s->top1+1==s->top2)//栈已满，不能再push新元素
return ERROR;
if(stackNumber==1)   //栈1有元素进栈
s->data[++s->top1]=e;//若栈1则先top+1后给数组元素赋值
else if(stackNumber==2) //栈2有元素进栈
s->data[--s->top2]==e;//若栈2则先top-1后给数组元素赋值
return OK;
}

/*若栈不空，则删除s的栈顶元素,用e返回其值，并返回OK，否则返回ERROR；*/

Status Pop(SqDoubleStack *s,SElemType *e,int stackNumber)
{
if(stackNumber==1)
{
if(s->top1==-1)
return ERROR;//说明栈1是空栈，溢出
*e->data[s->top1--];//将栈1的栈顶元素出栈
}
else if(stackNumber==2)
{
if(s->top2==MAXSIZE)
return ERROR;//说明栈2是空栈，溢出
*e=s->data[s->top2++];//将栈2的栈顶元素出栈
}
return OK;
}

栈的链式存储结构

typedef struct StackNode
{
SElemtype data;
struct StackNode *next;
}StackNode,*LinkStack;

typedef struct LinkStack
{
LinkStack top;
int count;
}LinkStack;

/*插入元素e为新的栈顶元素*/

status Push(LinkStack *s,SElemType e)
{
LinkStack s=(LinkStackPtr)malloc(sizeof(StackNode));
s->data=e;
s->next=s->top;//把当前的栈顶元素赋值给结点的直接后继
s->top=e;//将新的结点s赋值给栈顶指针
s->count++;
return OK;
}

/*若栈不空，则删除s的栈顶元素，并用e返回其值，并返回OK,否则返回ERROR;*/

status Pop(LinkStack *s,SElemType *e)
{
LinkStack p;
if(StackEmpty(*s));
return ERROR;
*e=s->top->data;
p=s->top; //将栈顶结点赋值给p，
s->top=s->top->next;//使得栈顶指针下移一位，指向后一结点
free(p);//释放结点
s->count--;
return OK;
}

栈的应用--递归

1,斐波那契数列

2,后缀(逆波兰)表示法定义//不懂啊

循环队列

详细请参考大话数据结构P112-P116

typedef int QElemtype;//QElemtype类型根据实际情况，这里定义为int
typedef struct
{
QElemtype data[MAXZIZE];
int front;//头指针
int rear;//尾指针，若队列不空，指向队尾元素的下一个位置
}Squeue;

//初始化一个空队列

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

//循环队列求长度

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

//循环队列的入队操作

statuas EnQueue(SqQueue *Q,QElemTYpe e)
{
if((Q->rear+1)%MAXSIZE==Q->front)//队列未满
return ERROR;
Q->data[Q->rear]=e;//将元素e赋值给队尾
Q->rear=(Q->rear+1)%MAXSIZE;//指针向后移动一位

return OK;
}

队列的链式存储结构与实现

typedef int QElemType

typedef struct QNode//结点结构
{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;

typedef struct//队列的链表结构
{
QueuePtr front,rear;//队头，队尾指针
}LinkQueue;

//插入元素e为Q的新的队尾元素

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;//把拥有元素e新结点s赋值给原队尾结点的后继
Q->rear=s;//把当前的s设置为队尾结点吗，rear指向s
return OK;
}

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

//若队列不空，删除Q的队头元素，并用e返回其值，并返回OK，否则，返回ERROR

ststus DeQueue(LinkQueue *Q,QElemType *e)
{
QueuePtr p;
if(Q->front==Q->rear)
return ERROR;
p=Q->front->next;//将欲删除的队头结点暂时存给p，
*e=p->data;//将欲删除的队头结点的值赋值给e
Q->front->next=p->next;//将原队头结点后继p->next赋值给头结点后继·

if(Q->rear==p)//若队头是队尾，则删除后将rear指向头结点，
Q->rear=Q->front;
free(p);
return OK;
}