考研数据结构--栈和队列

最新推荐文章于 2024-06-16 21:53:07 发布
最新推荐文章于 2024-06-16 21:53:07 发布
阅读量478 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 考研 数据结构 链表 算法 栈和队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73856491/article/details/130204749
版权

栈和队列

文章目录

栈

内容

栈：栈的抽象数据类型定义、栈的存储表示及基本操作实现、栈的应用

栈的定义（特点）

栈是一种后进先出（LIFO）的线性表，只能在一端进行插入和删除操作，这一端称为栈顶，另一端称为栈底。

打个比方：

有一个胡同很窄只能通过一辆车，而且是死胡同，只能从胡同口进出，如果第一个进入，出去会很麻烦，需要所有的车辆出去后才能出去，如图：

在这里插入图片描述

栈的存储表示

栈的存储表示有两种方式：顺序栈和链栈。顺序栈是用一组地址连续的存储单元依次存放从栈底到栈顶的数据元素，用一个变量top记录栈顶元素的位置。链栈是用链表存放数据元素，每个结点包含数据域和指针域，用一个指针top指向栈顶结点。

顺序存储方式

在这里插入图片描述

链式存储方式

在这里插入图片描述

栈的基本操作

栈的基本操作有以下几种：

  • 初始化：创建一个空栈
  • 判空：判断栈是否为空
  • 进栈：在栈顶插入一个元素
  • 出栈：删除并返回栈顶元素
  • 取栈顶：返回但不删除栈顶元素

栈的顺序存储方式和基本操作实现

顺序栈的定义
//定义顺序栈结构体类型
#define MaxSize 50 //定义栈的最大长度
typedef struct{
    int data[MaxSize]; //存放栈中元素
    int top; //栈顶指针
}SqStack;

在这里插入图片描述

顺序栈的初始化
//初始化栈
void InitStack(SqStack &S){
    S.top = -1; //将栈顶指针置为-1，表示空栈
}
顺序栈的判空
//判断栈是否为空
bool Empty(SqStack S){
    return S.top == -1; //栈顶指针为-1，说明栈为空
}
顺序栈的判满
//判断栈是否已满
bool Full(SqStack S){
    return S.top == MaxSize - 1; //栈顶指针为MaxSize-1，说明栈已满
}
顺序栈的进栈

在这里插入图片描述

//进栈
bool Push(SqStack &S, int x){
    if(Full(S)) return false; //栈已满，无法进栈
    S.data[++S.top] = x; //栈顶指针加1，将元素x放入栈顶
    return true;
}
顺序栈的出栈

在这里插入图片描述

//出栈
bool Pop(SqStack &S, int &x){
    if(Empty(S)) return false; //栈为空，无法出栈
    x = S.data[S.top--]; //将栈顶元素赋值给x，栈顶指针减1
    return true;
}
取栈顶元素
//取栈顶元素
bool GetTop(SqStack S, int &x){
    if(Empty(S)) return false; //栈为空，无法取栈顶元素
    x = S.data[S.top]; //将栈顶元素赋值给x
    return true;
}
main函数测试
//测试代码
int main(){
    SqStack S;
    InitStack(S);
    if (Empty(S))printf("栈为空\n");
    if (Full(S)){
        printf("栈满\n");
    } else{
        printf("栈未满\n");
    };
    for(int i = 1; i <= 10; i++){
        Push(S, i);
    }
    int x;
    GetTop(S,x);
    printf("%d ", x);
    printf("\n");
    while(!Empty(S)){
        Pop(S, x);
        printf("%d ", x);
    }
    printf("\n");
    return 0;
}

栈的链式存储方式和基本操作实现

链栈的定义
//定义链栈结构体类型
typedef struct LinkNode{
    int data; //存放栈中元素
    struct LinkNode *next; //指向下一个结点的指针
}LinkNode, *LinkStack;
链栈的初始化

在这里插入图片描述

//初始化栈
void InitStack(LinkStack &S){
    S = NULL; //将栈顶指针置为NULL，表示空栈
}
链栈的判空
//判断栈是否为空
bool Empty(LinkStack S){
    return S == NULL; //栈顶指针为NULL，说明栈为空
}
链栈的进栈

在这里插入图片描述

//进栈
bool Push(LinkStack &S, int x){
    LinkNode *p = (LinkNode *)malloc(sizeof(LinkNode)); //分配新结点空间
    if(p == NULL) return false; //分配失败，返回false
    p->data = x; //将元素x赋值给新结点
    p->next = S; //新结点的指针域指向栈顶结点
    S = p; //栈顶指针指向新结点
    return true;
}
链栈的出栈

在这里插入图片描述

//出栈
bool Pop(LinkStack &S, int &x){
    if(Empty(S)) return false; //栈为空，无法出栈
    LinkNode *p = S; //p指向栈顶结点
    x = p->data; //将栈顶元素赋值给x
    S = p->next; //栈顶指针指向下一个结点
    free(p); //释放原栈顶结点空间
    return true;
}
取栈顶元素
//取栈顶元素
bool GetTop(LinkStack S, int &x){
    if(Empty(S)) return false; //栈为空，无法取栈顶元素
    x = S->data; //将栈顶元素赋值给x
    return true;
}
main函数测试
int main(){
    LinkStack S;
    InitStack(S);
    if (Empty(S))printf("栈为空\n");
    for(int i = 1; i <= 10; i++){
        Push(S, i);
    }
    int x;
    GetTop(S,x);
    printf("%d ", x);
    printf("\n");
    while(!Empty(S)){
        Pop(S, x);
        printf("%d ", x);
    }
    printf("\n");
    return 0;
}

栈的应用

栈的应用有很多，例如：

  • 括号匹配：用一个栈存放左括号，遇到右括号时出栈并匹配，最后判断栈是否为空

  • 表达式求值：用两个栈分别存放操作数和运算符，按照运算符优先级和结合性进行计算

  • 递归实现：用一个栈存放函数调用时的参数、返回地址和局部变量，实现递归过程

括号匹配(注意栈中数据元素类型改为char)

在这里插入图片描述

  1. switch语句匹配实现

    //栈的应用:括号匹配
bool BracketMatch(char exp[]){
    SqStack S; //定义一个顺序栈
    //LinkStack S;//定义一个链栈
    InitStack(S); //初始化栈
    for (int i = 0; exp[i] !='\0'; ++i) { //遍历表达式
        switch(exp[i]){ //根据字符类型进行分类讨论
            case '(':
            case '[':
            case '{':
                Push(S, exp[i]); //左括号进栈
                break;
            case ')':
            case ']':
            case '}':
                if(Empty(S)) return false; //栈为空，说明右括号多余
                char topElem;
                Pop(S, topElem); //取出栈顶元素
                if((exp[i] == ')' && topElem != '(') || //右括号与左括号不匹配
                   (exp[i] == ']' && topElem != '[') ||
                   (exp[i] == '}' && topElem != '{')){
                    return false;
                }
                break;
            default:
                break;
        }
    }
    return Empty(S); //如果栈为空，说明括号匹配
}

  2. if…else…判断语句实现

    //栈的应用:括号匹配
bool BracketMatch(char exp[]){
    SqStack S;
    InitStack(S);
    for(int i = 0; exp[i] != '\0'; i++){
        if(exp[i] == '(' || exp[i] == '[' || exp[i] == '{'){ //左括号进栈
            Push(S, exp[i]);
        }
        else if(exp[i] == ')' || exp[i] == ']' || exp[i] == '}'){ //右括号出栈
            if(Empty(S)) return false; //栈为空，说明右括号多余
            char topElem;
            Pop(S, topElem); //取出栈顶元素
            if(exp[i] == ')' && topElem != '(') return false; //右括号与左括号不匹配
            if(exp[i] == ']' && topElem != '[') return false; //右括号与左括号不匹配
            if(exp[i] == '}' && topElem != '{') return false; //右括号与左括号不匹配
        }
    }
    return Empty(S); //如果栈为空，说明括号匹配
}

main函数测试

int main(){
    char exp1[] = "((()))";
    char exp2[] = "(()())";
    char exp3[] = "(()))";
    char exp4[] = "((){}[])";
    char exp5[] = "((){[}])";
    if(BracketMatch(exp1)) printf("exp1匹配\n");
    else printf("exp1不匹配\n");
    if(BracketMatch(exp2)) printf("exp2匹配\n");
    else printf("exp2不匹配\n");
    if(BracketMatch(exp3)) printf("exp3匹配\n");
    else printf("exp3不匹配\n");
    if(BracketMatch(exp4)) printf("exp4匹配\n");
    else printf("exp4不匹配\n");
    if(BracketMatch(exp5)) printf("exp5匹配\n");
    else printf("exp5不匹配\n");
    return 0;
}
表达式求值

计算中缀表达式的值的代码是一种利用栈结构来实现的方法，它需要用到两个栈，一个用于存储操作数，一个用于存储运算符。它的基本思路是：

  1. 从左到右扫描中缀表达式，遇到操作数就压入操作数栈，遇到运算符就进行比较。
  2. 如果运算符栈为空，或者栈顶运算符为左括号，或者当前运算符优先级高于栈顶运算符，就直接压入运算符栈。
  3. 如果当前运算符为右括号，就依次弹出运算符栈顶的运算符，并从操作数栈中弹出相应的操作数，进行计算，并将结果压入操作数栈，直到遇到左括号为止，然后弹出左括号。
  4. 如果当前运算符优先级低于或等于栈顶运算符，就弹出栈顶运算符，并从操作数栈中弹出相应的操作数，进行计算，并将结果压入操作数栈，然后再次比较当前运算符和新的栈顶运算符，重复这个过程，直到满足条件2或者扫描完毕为止。
  5. 当中缀表达式扫描完毕后，如果运算符栈中还有运算符，就依次弹出，并从操作数栈中弹出相应的操作数，进行计算，并将结果压入操作数栈，直到运算符栈为空为止。
  6. 此时操作数栈中只有一个元素，就是最终的计算结果。

在这里插入图片描述

两个栈的代码

#include <cstdio>
#define MaxSize 50
//定义一个存储字符的栈结构
typedef struct {
    char data[MaxSize]; //用数组存储栈元素
    int top; //用一个变量记录栈顶位置
}SqStackChar;

//定义一个存储双精度浮点数的栈结构
typedef struct {
    double data[MaxSize]; //用数组存储栈元素
    int top; //用一个变量记录栈顶位置
}SqStackDouble;

//初始化字符栈，将栈顶位置设为-1，表示空栈
void InitStack(SqStackChar &S){
    S.top = -1;
}
//初始化双精度浮点数栈，将栈顶位置设为-1，表示空栈
void InitStack(SqStackDouble &S){
    S.top = -1;
}

//判断字符栈是否为空，如果为空返回true，否则返回false
bool Empty(SqStackChar S){
    return S.top ==-1;
}
//判断双精度浮点数栈是否为空，如果为空返回true，否则返回false
bool Empty(SqStackDouble S){
    return S.top ==-1;
}
//判断字符栈是否为满，如果为满返回true，否则返回false
bool Full(SqStackChar S){
    return S.top == MaxSize-1;
}
//判断双精度浮点数栈是否为满，如果为满返回true，否则返回false
bool Full(SqStackDouble S){
    return S.top == MaxSize-1;
}
//将一个字符压入字符栈，如果成功返回true，否则返回false
bool Push(SqStackChar &S,char n){
    if (Full(S))return false; //如果栈满，无法压入，返回false
    S.data[++S.top] = n; //将字符n存入栈顶位置，并将栈顶指针加一
    return true; //返回true表示成功
}
//将一个双精度浮点数压入双精度浮点数栈，如果成功返回true，否则返回false
bool Push(SqStackDouble &S,double n){
    if (Full(S))return false; //如果栈满，无法压入，返回false
    S.data[++S.top] = n; //将双精度浮点数n存入栈顶位置，并将栈顶指针加一
    return true; //返回true表示成功
}
//将一个字符从字符栈弹出，并赋值给n，如果成功返回true，否则返回false
bool Pop(SqStackChar &S,char &n){
    if (Empty(S))return false; //如果栈空，无法弹出，返回false
    n = S.data[S.top--]; //将栈顶元素赋值给n，并将栈顶指针减一
    return true; //返回true表示成功
}
//将一个双精度浮点数从双精度浮点数栈弹出，并赋值给n，如果成功返回true，否则返回false
bool Pop(SqStackDouble &S,double &n){
    if (Empty(S))return false; //如果栈空，无法弹出，返回false
    n = S.data[S.top--]; //将栈顶元素赋值给n，并将栈顶指针减一
    return true; //返回true表示成功
}

//取字符栈的栈顶元素，并赋值给n，如果成功返回true，否则返回false
bool GetTop(SqStackChar S,char &n){
    if (Empty(S))return false; //如果栈空，无法取得元素，返回false
    n = S.data[S.top]; //将栈顶元素赋值给n
    return true;//返回true表示成功
}
利用中缀转后缀的思想完成求值
//返回运算符的优先级
int Precedence(char op){
    switch(op){
        case '+': //加号的优先级为1
        case '-': return 1; //减号的优先级为1
        case '*': //乘号的优先级为2
        case '/': return 2; //除号的优先级为2
        case '(': return 0; //左括号的优先级为0，最低


    }
}

//对两个操作数进行运算
double Operate(double a, char op, double b){
    switch(op){
        case '+': return a + b; //加法运算
        case '-': return a - b; //减法运算
        case '*': return a * b; //乘法运算
        case '/': return a / b; //除法运算，注意除数不能为0
    }
}

//计算中缀表达式的值
double EvaluateExpression(char exp[]){
    SqStackChar notation; //定义一个存储运算符的栈
    SqStackDouble number; //定义一个存储运算数的栈
    InitStack(notation); //初始化运算符栈
    InitStack(number); //初始化运算数栈
    int i=0;
    while (exp[i] !='\0'){ //遍历中缀表达式的每个字符
        if(exp[i] >= '0' && exp[i] <= '9') { //如果是数字
            double x = 0;
            while (exp[i] >= '0' && exp[i] <= '9') { //将数字字符转换为数字
                x = x * 10 + exp[i] - '0';
                i++;
            }
            Push(number, x); //将数字压入操作数栈
        } else{ //如果是符号
            if (Empty(notation)) {
                Push(notation, exp[i]) ;//符号栈中无符号，直接入栈
                i++;
                continue;
            }
            if (exp[i] == '('){
                Push(notation, exp[i]) ;//符号为左括号，入栈
                i++;
                continue;
            }
            char op ;
            GetTop(notation,op); //获取符号栈顶的运算符
            if (exp[i] == ')') { //符号为右括号
                while (true) {
                    Pop(notation, op); //弹出符号栈顶的运算符
                    if (op != '(') { //如果不是左括号，说明还在括号内部，需要计算
                        double a = 0, b = 0;
                        Pop(number, b); //弹出操作数栈顶的两个数作为运算数
                        Pop(number, a);
                        Push(number, Operate(a, op, b)); //将运算结果压入操作数栈
                    } else { //如果是左括号，说明括号内部已经计算完毕，跳出循环
                        i++;
                        break;
                    }
                }
            } else if ( Precedence(exp[i]) > Precedence(op) ){ //如果当前符号的优先级大于符号栈顶的优先级，直接入栈
                Push(notation, exp[i]) ;
                i++;
                continue;
            } else{ //如果当前符号的优先级小于等于符号栈顶的优先级，需要先计算前面的表达式，再入栈
                Pop(notation,op); //弹出符号栈顶的运算符
                double a , b ;
                Pop(number,b); //弹出操作数栈顶的两个数作为运算数
                Pop(number,a);
                Push(number,Operate(a,op,b)); //将运算结果压入操作数栈
            }

        }
    }
    while (!Empty(notation)){ //当中缀表达式遍历完毕后，如果符号栈还有元素，继续计算直到为空
        char op;
        Pop(notation,op); //弹出符号栈顶的运算符
        double a , b ;
        Pop(number,b); //弹出操作数栈顶的两个数作为运算数
        Pop(number,a);
        Push(number,Operate(a,op,b)); //将运算结果压入操作数栈
    }
    double result;
    Pop(number, result); //弹出操作数栈的栈顶元素作为表达式的值
    return result;
}

main函数

int main(){
    char exp[MaxSize];
    //char exp[] = "20*(10+10)";
    printf("请输入中缀表达式：\n");
    scanf("%s", exp);
    printf("中缀表达式的值为：%lf", EvaluateExpression(exp));
    return 0;
}
递归实现

栈的应用：递归实现是一个常见的数据结构和算法的话题。递归是一种程序设计技巧，它可以让一个函数直接或间接地调用自身，从而将一个复杂的问题分解为更小的子问题。递归的实现需要借助栈这种数据结构，因为栈具有后进先出的特点，可以保存函数调用时的返回地址、参数、局部变量等信息，以便在函数返回时恢复现场。

概述：
  • 递归函数通常有三个部分：递归终止条件、递归前进段和递归返回段。当终止条件满足时，递归返回；当终止条件不满足时，递归前进；递归返回段是在每次递归调用之后执行的操作。
  • 递归函数在调用自身之前，会将当前的状态（包括参数、局部变量、返回地址等）压入栈中，形成一个调用帧；在调用自身之后，会从栈中弹出上一层的状态，恢复现场。所有的调用帧形成一个调用栈。
  • 递归函数可以看作是两个过程：“递"和"归”。"递"是指不断地向更小的子问题前进，直到达到终止条件；"归"是指从最小的子问题开始返回，依次执行返回段的操作，直到回到最初的问题。
优点：
  • 代码简洁清晰，可读性更好
  • 可以解决一些循环难以解决或无法解决的问题
  • 可以利用栈实现反向输出或倒序遍历
缺点：
  • 时间和空间消耗比较大，因为每次调用都需要分配栈空间和压入弹出数据
  • 很多计算都是重复的，因为同一个子问题可能会被多次调用
  • 调用栈可能会溢出，因为栈的大小是有限的
针对栈的缺点可以进行尾递归优化

尾递归是一种特殊的递归形式，它是指在函数的最后一步调用自身，而不需要做任何其他的操作。尾递归可以避免栈溢出的风险，也可以节省空间和时间，因为它不需要保存每次调用的状态，只需要保留一个栈帧即可。

//一个简单的递归函数，计算n的阶乘
int factorial(int n){
    if(n == 0 || n == 1){ //递归终止条件，当n为0或1时，返回1
        return 1;
    }
    else{ //递归调用，当n大于1时，返回n乘以n-1的阶乘
        return n * factorial(n-1);
    }
}

//一个简单的非递归函数，计算n的阶乘
int factorial(int n){
    int result = 1; //定义一个变量存储结果
    for(int i = 1; i <= n; i++){ //循环从1到n，依次乘以i
        result *= i;
    }
    return result; //返回结果
}

//一个尾递归函数，计算n的阶乘
int factorial(int n, int acc){ //定义一个累积参数acc，用来存储中间结果
    if(n == 0 || n == 1){ //递归终止条件，当n为0或1时，返回acc
        return acc;
    }
    else{ //递归调用，在最后一步将n-1和n乘以acc作为参数传入
        return factorial(n-1, n * acc);
    }
}

//调用尾递归函数时，需要将初始值1作为acc参数传入
int result = factorial(5, 1); //计算5的阶乘

队列

队列是一种先进先出（FIFO）的线性表，只允许在一端（称为队头）进行删除操作，而在另一端（称为队尾）进行插入操作。队列中没有元素时，称为空队列。

在这里插入图片描述

队列的存储表示有两种方式：顺序存储和链式存储。

队列的基本操作有以下几种：

  • 初始化操作：InitQueue(Q)。构造一个空队列Q。
  • 判空操作：QueueEmpty(Q)。判断队列Q是否为空，若为空则返回true，否则返回false。
  • 入队操作：EnQueue(Q)。将元素x插入到队列Q的队尾。
  • 出队操作：DeQueue(Q,x)。删除队列Q的队头元素，并用x返回其值。
  • 取队头操作：GetHead(Q,x)。用x返回队列Q的队头元素，但不删除该元素。

队列的链式存储

队列的链式存储是指使用链表来实现队列的存储结构。相比于顺序存储，链式存储不需要预先分配一定大小的空间，可以动态地分配和释放内存，因此更加灵活。同时，链式存储也避免了顺序存储中可能出现的“假溢出”问题。

在这里插入图片描述

方式1

定义
//
// Created by lenovo on 2023/4/17.
//
#include <cstdlib>
#include <cstdio>

// 链式队列结点
typedef struct LinkNode {
    int data; // 数据域
    LinkNode *next; // 指针域
}LinkNode;

// 链式队列结构体
typedef struct {
    LinkNode *front, *rear; // 队头指针和队尾指针
}LinkQueue;
初始化
// 初始化队列
void InitQueue(LinkQueue &Q){
    Q.front = Q.rear = (LinkNode*) malloc(sizeof(LinkNode)); // 初始化队头指针和队尾指针
    Q.front->next = NULL; // 队头指针的下一个结点为空
}
判空
// 判断队列是否为空
bool Empty(LinkQueue Q){
    return Q.front == Q.rear; // 队头指针等于队尾指针，说明队列为空
}
入队列

在这里插入图片描述

// 入队列
void EnQueue(LinkQueue &Q, int x){
    LinkNode *s = (LinkNode*) malloc(sizeof(LinkNode)); // 创建新结点
    s->data = x; // 将元素x放入新结点的数据域
    s->next = NULL; // 新结点的指针域为空
    Q.rear->next = s; // 将新结点插入队尾
    Q.rear = s; // 队尾指针指向新结点
}
出队列

在这里插入图片描述

// 出队列
bool DeQueue(LinkQueue &Q, int &x){
    if (Q.front == Q.rear) return false; // 队列为空，无法出队列
    LinkNode *s = Q.front->next; // 指向队头结点
    x = s->data; // 将队头元素赋值给x
    Q.front->next = s->next; // 队头指针指向下一个结点
    if (Q.rear == s) Q.rear = Q.front; // 如果队列为空，队尾指针置为NULL
    free(s); // 释放原队头结点空间
    return true;
}
取队头元素
// 取队头元素
bool GetHead(LinkQueue Q, int &x){
    if (Empty(Q)) return false; // 队列为空，无法取队头元素
    x = Q.front->next->data; // 将队头元素赋值给x
    return true;
}
main 方法测试
int main(){
    LinkQueue Q;
    InitQueue(Q); // 初始化队列
    if (Empty(Q)) printf("队列为空\n"); // 判断队列是否为空
    EnQueue(Q, 1); // 入队列
    EnQueue(Q, 2);
    EnQueue(Q, 3);
    EnQueue(Q, 4);
    EnQueue(Q, 5);
    int x;
    GetHead(Q, x); // 取队头元素
    printf("队头元素：%d\n", x);
    while (!Empty(Q)){ // 遍历队列
        DeQueue(Q, x); // 出队列
        printf("%d ", x);
    }
    printf("\n");
    if (Empty(Q)) printf("队列为空\n"); // 判断队列是否为空
    return 0;
}

方式2

//队列的抽象数据类型定义
typedef struct LinkNode{
    int data; //数据域
    struct LinkNode *next; //指针域
}LinkNode, *LinkQueue;

//队列的存储表示与基本操作实现
//初始化队列
void InitQueue(LinkQueue &Q){
    Q = (LinkNode*)malloc(sizeof(LinkNode)); //创建头结点
    Q->next = NULL; //头结点的指针域置为NULL
}

//判断队列是否为空
bool Empty(LinkQueue Q){
    return Q->next == NULL; //头结点的指针域为NULL，说明队列为空
}

//进队列
void CreateList_Tail(LinkQueue &L){
    int x;//输入的数据
    LinkNode *tailNode = L; //tailNode指向尾结点，初始时指向头结点
    scanf("%d",&x); //读入第一个数据
    while (x!=9999){ //用9999作为结束标志
        LinkNode *s = (LinkNode *) malloc(sizeof(LinkNode)); //分配新结点空间
        if (s == NULL) exit(-1); //分配失败退出
        s->next = NULL; //尾结点的指针域置空
        s->data = x; //新结点的数据域赋值为x
        tailNode->next = s; //原尾结点的指针域指向新结点
        tailNode = s; //tailNode指向新的尾结点
        scanf("%d",&x); //读入下一个数据
    }
    // tailNode->next =NULL
}

//出队列
bool DeQueue(LinkQueue &Q, int &x){
    if(Empty(Q)) return false; //队列为空，无法出队列
    LinkNode *p = Q->next; //p指向队头结点
    x = p->data; //将队头元素赋值给x
    Q->next = p->next; //队头指针指向下一个结点
    if(Q->next == NULL) Q = NULL; //如果队列为空，队尾指针置为NULL
    free(p); //释放原队头结点空间
    return true;
}

//取队头元素
bool GetHead(LinkQueue Q, int &x){
    if(Empty(Q)) return false; //队列为空，无法取队头元素
    x = Q->next->data; //将队头元素赋值给x
    return true;
}

int main(){
    LinkQueue Q;
    InitQueue(Q);
    if (Empty(Q))printf("队列为空\n");
    CreateList_Tail(Q);
    int x;
    GetHead(Q,x);
    printf("对头元素：%d\n",x);
    while(!Empty(Q)){
        DeQueue(Q, x);
        printf("%d ", x);
    }
    printf("\n");
    return 0;

}

循环队列（顺序）

循环队列是一种线性数据结构，它具有队列的所有特点，同时在实现上采用了循环数组的思想，可以更高效地利用存储空间。

在循环队列的实现中，需要维护队头指针和队尾指针，它们的初始值都为0，表示空队列。

当队列中有元素进队列时，队尾指针加1；当队列中有元素出队列时，队头指针加1。

为了实现循环，当队尾指针到达数组的末尾时，需要将其置为0，从而形成一个循环。

定义
//
// Created by lenovo on 2023/4/17.
//
#include <cstdlib>
#include <cstdio>

#define MAXSIZE 5

//队列的抽象数据类型定义
typedef struct{
    int data[MAXSIZE]; //存放队列元素
    int front, rear; //队头指针和队尾指针
}SqQueue;
初始化
//队列的存储表示与基本操作实现
//初始化队列
void InitQueue(SqQueue &Q){
    Q.front = Q.rear = 0; //队头指针和队尾指针置为0，表示空队列
}
判空
//判断队列是否为空
bool Empty(SqQueue Q){
    return Q.front == Q.rear; //队头指针等于队尾指针，说明队列为空
}
判满
//判断队列是否已满
bool Full(SqQueue Q){
    return (Q.rear + 1) % MAXSIZE == Q.front; //队尾指针的下一个位置等于队头指针，说明队列已满
}
入队列
//进队列
bool EnQueue(SqQueue &Q, int x){
    if(Full(Q)) return false; //队列已满，无法进队列
    Q.data[Q.rear] = x; //将元素x放入队尾
    Q.rear = (Q.rear + 1) % MAXSIZE; //队尾指针加1
    return true;
}
出队列
//出队列
bool DeQueue(SqQueue &Q, int &x){
    if(Empty(Q)) return false; //队列为空，无法出队列
    x = Q.data[Q.front]; //将队头元素赋值给x
    Q.front = (Q.front + 1) % MAXSIZE; //队头指针加1
    return true;
}
取对头元素
//取队头元素
bool GetHead(SqQueue Q, int &x){
    if(Empty(Q)) return false; //队列为空，无法取队头元素
    x = Q.data[Q.front]; //将队头元素赋值给x
    return true;
}
main方法测试
int main(){
    SqQueue Q;
    InitQueue(Q);
    if (Empty(Q))printf("队列为空\n");
    EnQueue(Q,1);
    EnQueue(Q,2);
    EnQueue(Q,3);
    EnQueue(Q,4);
    EnQueue(Q,5);
    if (Full(Q))printf("队列为满\n");
    int x;
    GetHead(Q,x);
    printf("对头元素：%d\n",x);
    while(!Empty(Q)){
        DeQueue(Q, x);
        printf("%d ", x);
    }
    printf("\n");
    return 0;

}
Maverick_曲流觞
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
考研专业课-数据结构-思维导图
12-30
打开方式：Freemind、幕布等思维导图软件  “数据结构”是计算机、...资源中包含数据结构绪论，线性表，栈、队列和数组，串，树与二叉树，即王道书前五章内容，均为本人考研过程中自己整理总结。后续内容会逐步更新。
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
【408考研】数据结构 —— 第三章 栈、队列
CS@zeny的博客
08-16 753
计算机考研全国统考408科目之一 ：数据结构， 第三章栈和队列学习笔记。
计算机考研数据结构---栈和队列
weixin_43970560的博客
07-17 1280
** 第三章 栈和队列 ** 一、栈的基本概念 1.1 栈的定义 栈（Stack）是只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 空栈：不含任何元素的空表。 栈顶：线性表允许进行插入或删除的那一端。 栈底：固定的，线性表不允许进行插入和删除操作的一端。 假如某个栈S={a1,a2,a3,a4,a5}，a1为栈底元素，a5为栈顶元素。进栈次序a1->a2->a3->a4->a5，出栈次序：a5->a4->a3-
数据结构---栈和队列
qq_46370017的博客
07-10 375
若有队头元素出队，队头指针会后移，静态数组出现空闲空间，如果此时有新元素入队，要能插入到队列前面空闲的位置。比如，假设静态数组最大容量为10，在rear为9时，插入元素，之后执行此语句使队尾指针指向下一个待插入位置，则此时 (9+1)%10=0，就指向数组下表为0的位置，最简单的情况是依次进栈，所有元素都进栈之后，进行出栈操作，此时出栈的顺序即为：e,d,c,b,a。注意，由于队列操作受限，队头删除，队尾插入，因此需要两个指针分别指向队头和队尾。
数据结构-考研-栈和队列
qq_45044146的博客
09-06 169
栈的基本操作 栈常考的题型： 2.栈的特点：先进后出 按照存储方式分为顺序栈和链栈 顺序栈的定义： 初始条件不同，判断栈空和栈满的条件也不同，注意一下 队列 线性表，栈，队列之间关系。 栈和队列都是一种特殊的线性表 判断队列已满/已空 对于队头队尾指针 栈的应用（后进先出） 1.用栈实现括号匹配 2.栈在递归中应用 栈在递归中的调用 数组 ...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
考研数据结构-栈和队列
sjxgghg的博客
04-19 349
栈(stack) 定义： 栈是一种只能在一段进行插入或删除操作的线性表。 可以插入删除的一端叫栈顶，另一端叫栈底。 逻辑结构： 栈的逻辑结构属于线性表，只不过在操作上加了一些约束。先进后出。 存储结构： 顺序栈： int stack[maxSize]; int top = -1; //入栈 stack[++top] = 1; //出栈 int x = stack[top--]; top == -1...
王道考研---栈和队列笔记
lwkai1004的博客
04-18 258
队列是只允许在一端进行插入（入队），在另一端删除（出队）的线性表。
24考研数据结构-队列2
VengaZ的学习博客
07-28 118
队列的链式存储和操作
【考研-数据结构】栈和队列
Manner11的博客
02-10 184
【考研-数据结构】栈和队列 1.栈 静态栈 #include <iostream> #define MaxSize 20 using namespace std; typedef struct SqStack { int data[MaxSize]; int top; }SqStack; //初始化栈 void InitStack(SqStack& s) { s.top = -1; } //入栈 bool PushStack(SqStack& s, int e) {
数据结构考研习题-第三章栈和队列.rar
03-08
数据结构考研习题-第三章栈和队列.rar
18版考研数据结构天勤课后习题全部代码-栈和队列.cpp
09-08
18版考研数据结构天勤课后习题全部代码-栈和队列，用于考研复习
计算机考研-数据结构知识点汇总.pdf
08-29
计算机考研数据结构知识点汇总 本资源摘要信息涵盖了计算机考研中的数据结构知识点，包括数据结构的基本概念、逻辑结构、存储结构、算法设计、线性表、链表、队列、栈等知识点。 一、数据结构基本概念 * 数据结构...
考研计组chap3存储系统
straight_out的博客
06-13 818
if未命中，有空行，填入Cache，else+1，无空行，找max，剔除，该行置0，else+1。每次访问一个，if为空，放入Cache行，count+1，if不空，命中，+1，未命中，替换min，if有同，FIFO or 行数小的。因为电容这边接地，为0V，so用高电平的时候MOS导电，电容充电表示1，之后断开MOS管，电荷就保存在了电容中，在另一端读就为1。m> T/r,模块会有空闲，无法达到最高效，增加成本；eg:4个Cache行，依次访问1，2，3，4，1，2，5，1，2，3，4，5主存块。
考研计组chap2数据的表示和运算（补充）
straight_out的博客
06-13 819
在FA的基础上加上四个标识器，从而可以进行有符号数加减对并行加法器进行优化根据数学推导，if将前面运行之后的结果一并送到后面，则效率会提高但是if太多，则线路就会很麻烦，so一般规定4个FA并行由此产生4位CLA加法器。
上海计算机考研避雷，25考研慎报
最新发布
qq_45018803的博客
06-16 810
在专业课方面，我一直在不断地做真题，并反复看王道讲义上的错题。此时，大家也需要回归到课本，
数据结构之B树
嫦娥妹妹等等我的博客
06-16 374
**节点的大小**：每个节点至少有 `t - 1` 个键值（除根节点外），最多有 `2t - 1` 个键值。1. **高效的磁盘读取**：由于每个节点包含多个键值和指针，B树减少了磁盘I/O操作的次数，提高了查找和更新的效率。- **数据库系统**：B树及其变种（如B+树、B*树）广泛用于数据库索引结构，支持快速的数据插入、删除和查询。- 每个节点最多有 `2t - 1` 个键值和 `2t` 个子节点指针，其中 `t` 是B树的最小度数。- **平衡性**：B树是一棵平衡树，所有叶子节点位于同一层。
西南交通大学考研数据结构和c语言真题
10-24
西南交通大学的考研数据结构和C语言真题主要涵盖了数据结构和C语言的基本概念、常见算法和数据结构的应用，是考研复习中的重点和难点。 数据结构部分的真题主要涉及线性表、栈和队列、链表和树、图和排序等知识点。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值