数据结构——栈和队列

目录

3.1栈和队列的定义和特点

3.2案例引入

3.3栈的实现和操作的实现

顺序栈的表示

顺序栈初始化

顺序栈是否为空

顺序表长度

清空顺序栈

销毁顺序栈

顺序栈的入栈

顺序栈的出栈

链栈的表示

链栈的初始化

链栈是否为空

链栈的入栈

链栈的出栈

取栈顶元素

3.4栈和递归

3.5队列的表示和操作的实现

顺序队表示

链队表示

3.6案例分析与实现

---

3.1栈和队列的定义和特点

• 栈和队列是两种常用的、重要的数据结构
• 栈和队列是限定插入和删除只能在表的“端点”进行的线性表
• 栈
  • 后进先出（FLFO）
  • 应用
    • 数据转换/括号匹配/行编辑顺序/迷宫求解/表达式求值/八皇后问题/函数调用/递归调用的实现
  • 
  • 栈仅在表尾进行插入、删除，表尾为栈顶（Top），表头为栈底(Base)
  • 插入元素到栈顶（表尾）的操作，称为入栈 = Push
  • 栈顶删除最后一个元素的操作，出栈 = Pop
  • 

• 

• 队列
  • 先进先出（FIFO）
  • 应用
    • 脱机打印输出/多用户系统排队/按用户优先级排队，每个优先级一个队列/实时控制系统/网络电文传输
  • 

3.2案例引入

• 栈
  • 进制转换
  • 括号匹配的检验
  • 表达式求值
• 队列
  • 舞伴问题

3.3栈的实现和操作的实现

• 栈的顺序存储——顺序栈
• 栈的链式存储——链栈
• 到栈底的数据元素，栈底在低地址端
  • top指针，指示栈顶元素
  • base指针，指示栈底元素
  • 
  • top通常指示真正的栈顶元素之上的下标地址
  • stacksize表示栈可使用的最大容量
  • 
• 使用数组作为顺序栈的特点
  • 简单，易产生溢出（数据大小固定）
  • 上溢：栈已经满，又要压入元素
  • 下溢：栈已经空，又要弹出元素

顺序栈的表示

#define MAXSIZE 100

typedef struct{

SElemType *base;

SElemType *top;

int stacksize;

}SqStack;

 

顺序栈初始化

Status InitStack(SqStack &S){

S.base = new SElemType[MAXSIZE];

if(!S.base) exit(OVERFLOW);

S.top = S.base;

S.stacksize = MAXSIZE;

return OK;

}

 

顺序栈是否为空

Status StackEmpty(SqStack S){

if(S.top == S.base)

return OK;

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 DestoryStack(SqStack &S){

if(!S.base){

delete S.base;

S.stacksize = 0;

S.base = S.top = NULL;

}

return OK;

}

 

顺序栈的入栈

Status Push(SqStack &S,SElemType e){

if(S.top - S.base == S.stacksize)

return ERROR;

*S.top++=e;

return OK;

}

 

顺序栈的出栈

Status Pop(SqStack &S,SElemType &e){

if(S.top == S.base)

return ERROR;

e = *--S.top;

return OK;

}

 

链栈的表示

typedef struct StackNode{

SElemType data;

struct StackNode *next;

}StackNode,*LinkStack;

LinkStack S;

 

链栈的初始化

void InitStack(LinkStack &S){

S = NULL;

return OK;

}

 

链栈是否为空

Status StackEmpty(LinkStack S){

if(S==NULL) return TRUE;

else return FALSE;

}

 

链栈的入栈

Status Push(LinkStack &S,SElemType e){

p = new StackNode;

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){

return S->data;

}

}

 

 

3.4栈和递归

• 递归定义：
  • 若一个对象部分包含它自己，或用它自己给自己定义，称这个对象是递归的
  • 若一个过程直接的或间接的调用自己，称这个过程是递归的过程
• 二叉树、广义表等都有用递归
• 递归就是把一个问题化成基本项和归纳项
• 
• 递归优缺点
  • 优点：结构清晰、程序易读
  • 缺点：时间开销大
• 解决方法
  • 用循环结构代替递归
  • 自用栈模拟系统的运行时栈

3.5队列的表示和操作的实现

• 插入元素称为入队，删除元素称为出队
• 队列的存储结构为链队和顺序队（循环顺序队）

顺序队表示

• 队列表示
  • 代码

#define MAXQSIZE 100

typedef struct{

QElemType *base;

int front;//头指针

int rear;//尾指针

}SqQueue;

• 存在假溢出问题，解决方法
  • 使用循环队列
  • 
  • Base[0]接在base[MAXQSIZE-1]之后，若rear+1==M，则令rear = 0；（利用模运算）
  • 插入
    • Q.base[Q.rear]=x;
    • Q.rear=(Q.rear+1)%MAXSIZE;
  • 删除
    • X = Q.base[s.front];
    • Q.front=(Q.front+1)%MAXSIZE
  • 对空
    • Front == rear
  • 队满
    • （Rear+1）%MAXQSIZE==front
• 队列的初始化
  • 代码

Status InitQueue(SqQueue &Q){

Q.base = new QElemType[MAXQSIZE];

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(SqQueue &Q,QElemType &e){

if(Q.front==Q.rear) return ERROR;

e = Q.base[Q.front];

Q.front = (Q.front+1)%MAXQSIZE;

return OK;

}

• 取队头元素
  • 代码

SElemType GetHead(SqQueue Q){

if(Q.front != Q.rear)

return Q.base[Q.front];

}

链队表示

• 无法估计所用队列的长度，就用链队列
• 

• 链队类型定义
  • 代码

#define MAXQSIZE 100

typedef struct Onode{

QElemType data;

struct Qnode *next;

}QNode, *QuenePtr;

• 链队初始化
  • 代码

Status InitQueue(LinkQueue &Q){

Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));

if(!Q.front) exit(OVERFLOW);

Q.front->next = NULL;

return OK;

}

 

• 销毁链队列
  • 代码

Status DestoryQueue(LinkQueue &Q){

while(Q.front){

p = Q.front->next;

free(Q.front);

Q.front = p;

}

return OK;

}

 

• 入队
  • 代码

Status EnQueue(LinkQueue &Q,QElemType e){

p = (QueuePtr)malloc(sizeof(QNode));

if(!p) exit(OVERFLOE);

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;

}

3.6案例分析与实现