栈和队列操作

栈，队列，一般线性表的关系

逻辑结构：一对一
存储结构：顺序表，链表
运算规则：随机，顺序存取（栈：后进后出
队列：后进先出
）

栈和队列的操作

顺序栈的操作

头文件及宏

#include "pch.h"
#include <iostream>
#include <fstream>
using namespace std;

#define OK			1
#define ERROR		0
#define OVERFLOW	-2
#define MAXSIZE		50

typedef int Status;			
typedef char SElemType;		

顺序栈的表示

#define MAXSIZE 100//最大长度

typedef struct
{
SElemType *base;//栈底
SElemType *top;//栈顶
int stacksize;//大小
}SqStack;

顺序栈的初始化

Status Initstack(SqStack &S)
{
S.base = new SElemType[MAXSIZE];//分配空间并检查空间是否分配失败
if(!S.base)  return OVERFLOW;//若失败则返回错误
S.top = S.base;//设置栈顶和栈底指针
S.stackSize = MAXSIZE;//设置栈大小
retrun OK;
}

判断顺序栈是否为空

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

求顺序栈的长度

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

清空顺序栈

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

销毁顺序栈

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

顺序栈进栈

1.判断是否栈满，若满则出错
2.元素e压入栈顶
3.栈顶元素加1

Status Push(SqStack &S,SElemType e)
{
if(S.top - S.base==S.stacksize)//判断栈满
	return ERROR;
*S.top++ = e;//先将e赋给头指针指向的元素，再将头指针＋1。
return OK;
}

顺序栈出栈

1.判断是否栈空，若空则出错
2.获取栈顶元素e
3.栈顶指针减1

Status Pop(SqStack &S,SElemType &e)
{
if(S.top == S.base)//判断栈空
	return ERROR;
e = *--S.top;//先将头指针指向的元素赋值给e，再将头指针减去1
return OK;
}

取顺序栈栈顶元素

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

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

链栈的具体操作

链栈的表示

栈顶指针即是链表的头指针

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

链栈的初始化

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

判断链栈是否为空

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

链栈的进栈

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

链栈的出栈

Status Pop(LinkStack &S,SElemType &e)
{
if(S==NULL) return ERROR;//判断是否栈空
e = S->data;
p = S;
S = S->next;
delete p;
return OK;
}

取链栈栈顶元素

SElemType GetTop(LInkStack S)
{
if(S == NULL) exit(1);
else
return S->data;
}

队列的操作

顺序队列的基础

空队标志：front == rear;
入队： base[rear++]=x;
出队：x=base[front++];

头文件及宏

#include <iostream>
#include <fstream>
using namespace std;

#define MAXQSIZE	100
#define OK			1
#define ERROR		0
#define OVERFLOW	-1

typedef char QElemType;
typedef char SElemType;
typedef int  Status;

队列的顺序表示

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

循环队列的具体操作

实现：利用“模”运算
入队：
base[rear]=x;
rear=(rear+1)%M;
出队：
x=base[front];
front=(fornt+1)%M;
判断队空队满：
队空：front = rear;
队满：(rear+1)%M=front;

循环队列的表示

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

循环队列的初始化

Status InitQueue(SqQueue &Q)
{
Q.base = new QElemType[MAXSIZE]//申请空间
if(!Q.base) exit(OVERFLOW);
Q.front=Q.rear=0;		//队空
return OK;
}

求循环链表的长度

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

循环队列入队

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

循环队列出队

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

链队列的具体操作

链队列的表示

typedef struct QNode{
QElemType data;
struct Qnode *next;
}Qnode,*QueuePtr;

typedef struct{
QueuePtr front;
QueuePtr rear;
}LinkQueue;

链队列的初始化

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

销毁链队列

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

判断链队列是否为空

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

求链队列的队头元素

Status GetHead(LinkQueue Q,QElemType &e)
{
if(Q.front==Q.rear) return ERROR;//队空，无法删除
e = Q.front->next->data;
return OK;
}

链队列入队

Status DeQueue(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;
}

链队列出队

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