栈和队列的使用_栈和队列的基本操作及应用-CSDN博客

本文链接：https://blog.csdn.net/qq_47896523/article/details/126879317

队列的顺序表示----用一维数组base[MAXQSIZE]

链队--队列的链式表示和实现(存在头结点)

栈的定义和特点

栈和队列是线性表的子集（插入和删除位置受限的线性表）
栈是限制在表的一端进行插入和删除操作的线性表(运算规则)

后进先出（LIFO）
Last In First Out

栈顶（Top）:允许插入、删除操作的一端，又称为表尾。用栈顶指针（top）来指示栈顶元素
栈底（Base）:固定端，又被称为表头
插入元素到栈顶（即表尾）的操作，称为入栈
从栈顶（表尾）删除最后一个元素的操作，称为出栈
用顺序栈或链栈存储均可，但以顺序栈更常见

栈的表示

栈的抽象数据类型的类型定义

ADT Stack{
	数据对象：D={Ai}
	数据关系：R={<Ai-1,Ai>}
	基本操作;初始化、进栈、出栈、取栈顶元素
}ADT Stack

栈的存储结构

由于栈本身就是线性表，于是栈也有顺序存储 (顺序栈) 和链式存储 (链栈)

顺序栈的存储方式：

同一般线性表的顺序存储结构完全相同
利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址端

附设top指针，指示栈顶元素在顺序栈中的位置(通常top指示真正的栈顶元素之上的下标地址)

另设base指针，指示栈底元素在顺序栈中的位置 (一般指向的下标为0)

用stacksize表示栈可用的最大容量 (下标为 0 -- stacksize-1)

栈空的标志

base == top

栈满的标志

top - base == stacksize

栈满的处理方法：①报错，返回操作系统； ②分配更大的空间，作为栈的存储空间，将原栈的内容移入新栈

使用数组作为顺序栈存储方式的特点

简单、方便、但易产生溢出(数组大小固定)

上溢：栈已经满，又要压入元素
下溢：栈已经空，还要弹出元素（一种结束条件）

顺序栈的表示和实现

#define MAXSIZE 100
typedef struct{
    SElemType *base;    //栈底指针
    SELemType *top;     //栈顶指针
    int stacksize;      //栈可用最大容量
}SqStack;

顺序栈的初始化

Status InitStack(SqStack &S){    //构造一个空栈
    S.base = new SElemType[MAXSIZE];    //分配SElemType类型的空间
    if(!S.base)    exit(OVERFLOW);    //存储分配失败
    S.top = S.base;        //栈顶指针等于栈底指针
    S.stacksize = MAXSIZE;
    return OK;
}

顺序栈判断是否为空

Status StackEmpty(SqStack S){
        //若栈为空，返回TRUE;否则返回FALSE
    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 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;    //先将e赋值给S的栈顶指针，然后栈顶指针++
    return OK;
}

链栈的表示与实现

链栈是运算受限的单链表，只能在链表头部进行操作

链栈的定义

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

栈顶存储的是an元素，next指针指向的是其前驱；a1存放在栈底位置
链表的头指针就是栈顶
不需要头结点
基本不存在栈满的情况（内存只要有空间）
空栈相当于头指针指向空
插入和删除仅在栈顶处执行

链栈的初始化

Status 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
    p -> data = e;            //将新结点数据域置为e
    p -> next = S;            //将新结点插入栈顶
    S = p;                    //修改栈顶指针
    return OK;
}

链栈的出栈

Status Pop(LinkStack &S,SElemType &e){
    if(S == NULL)    return ERROR;
    e = S -> data;
    p = S;            //用指针p记录被删除的结点
    S = S -> nxet;
    delete p;
    return OK;
}

取栈顶元素

SElemType GetTop(LinkStack S){
    if(S != NULL)
        return S -> data;
}

栈与递归

递归的定义

若一个对象部分地包含它自己，或用它自己给自己定义，则称这个对象是递归的
若一个过程直接地或间接地调用自己，则称这个过程是递归的过程

递归求n的阶乘

long Fact(long n){
    if(n == 0)    return 1;
    else return n*Fact(n-1);
}

//尾处递归可转变为循环
long Fact(long n){
    t = 1;
    for(i = 1;i <= n;i++)    t = t*i;
  return t;
}

分治法求解递归问题算法的一般形式

void p(参数表){
    if (递归结束条件)    可直接求解步骤        //基本项
    else p(较小的参数)；                    //归纳项
}

函数调用过程

调用前，系统完成：

①将实参、返回地址等传递给被调用函数

②为被调用函数的局部变量分配存储区

③将控制转移到被调用函数的入口

调用后，系统完成：

①保存被调用函数的计算结果

②释放被调用函数的数据区

③依照被调用函数保存的返回地址将控制转移到调用函数

递归的优缺点

优点：结构清晰，程序易读

缺点：每次调用要生成工作记录，保存状态信息，入栈；返回时要出栈，恢复状态信息。时间开销大

①递归程序在执行时需要系统提供栈来实现

②仿照递归算法执行过程中递归工作站的状态变化可写出相应的非递归程序

③改写后的非递归算法与原来的递归算法相比，结构不够清晰，可读性较差，有的还需要经过一系列优化