（Data Structure）数据结构第三章栈和队列

最新推荐文章于 2024-06-12 09:31:30 发布

置顶汽水汽水

最新推荐文章于 2024-06-12 09:31:30 发布

阅读量196

点赞数 2

文章标签：数据结构算法

本文链接：https://blog.csdn.net/m0_73120357/article/details/129865021

版权

3.1 栈（stack）

栈（Stack）是一种线性数据结构，它具有后进先出(Last-In-First-Out, LIFO)的特点。它可以看作是一个容器，只能在容器的一端进行插入和删除操作。在栈中，最后加入的元素会被最先删除，而最先加入的元素会被最后删除
栈有两个基本操作，即入栈(Push)和出栈(Pop)。入栈指在栈顶插入一个元素，出栈则是删除栈顶的元素。此外，还有一个获取栈顶元素但不删除的操作，称为Peek或Top。这些基本操作使得栈非常适合解决需要后进先出的问题，例如程序调用的返回值存储、表达式求值、括号匹配等问题

在这里插入图片描述

3.2 栈的顺序实现—顺序栈

栈是一种线性数据结构，具有以下存储特点：
连续存储：栈的元素在内存中是连续存储的，这使得栈的访问速度非常快。
后进先出（LIFO）：栈是一种后进先出的数据结构，即最后进入栈的元素最先出栈，而最先进入栈的元素最后出栈。
顶部元素：栈的操作都是在栈顶元素上进行的，因此栈的操作都是O(1)的时间复杂度。
有界性：栈有容量限制，即栈的大小是有限制的，当栈满时，继续入栈会导致栈溢出。
静态实现或动态实现：栈的实现可以是静态的，也可以是动态的。静态实现需要事先确定栈的容量，而动态实现则可以根据需要动态调整栈的大小。

总之，栈的存储特点使其成为一种非常高效的数据结构，适合在需要后进先出的场景下使用，例如表达式求值、递归函数调用等。

顺序栈的定义

// 定义栈结构体
typedef struct stack
{
    int *base;      // 栈底指针
    int *top;       // 栈顶指针
    int stack_size; // 栈大小
} stack;

顺序栈的初始化

// 初始化栈
void init_stack(stack *s)
{
    s->base = (int *)malloc(sizeof(int) * MAX_SIZE); // 为栈分配内存空间
    s->stack_size = MAX_SIZE;                        // 初始化栈大小
    s->top = s->base;                                // 初始化栈顶指针指向栈底
}

顺序栈栈空

// 判断栈是否为空
int is_empty(stack *s)
{
    if (s->base == s->top)
    {
        return 1; // 栈为空
    }
    return 0; // 栈不为空
}

顺序栈栈满

// 判断栈是否已满
int is_full(stack *s)
{
    if (s->top - s->base == s->stack_size)
    {
        return 1; // 栈已满
    }
    return 0; // 栈未满
}

顺序栈的入栈

// 入栈操作
void push_stack(stack *s, int data)
{
    if (is_full(s))
    {
        printf("栈满"); // 栈已满，无法入栈
        return;
    }
    *(s->top++) = data; // 入栈操作
}

顺序栈的出栈

void pop_stack(stack *s)
{
    // 如果栈为空，则打印提示信息并直接返回
    if (is_empty(s))
    {
        printf("栈空");
        return;
    }
    s->top--;                // 栈顶指针减1，指向下一个元素
    printf("%d\n", *s->top); // 打印栈顶元素的值
}

3.3 栈的链式存储—链栈

链栈的特点包括：

基于链表实现：链栈使用链表来存储元素，每个节点包含一个数据元素和一个指向下一个节点的指针
操作高效：由于每个节点已经指向了下一个节点，因此在插入和删除元素时不需要移动整个数据结构，只需要修改节点的指针即可，使得链栈的插入和删除操作非常高效
非连续存储：链栈不像顺序栈一样需要连续的存储空间，它可以通过指针链接任意地址的存储单元，因此不会出现存储空间不足的问题
大小可变：链栈的大小可以根据实际需要动态增加或减少，这使得它适用于需要频繁变化大小的场景
栈顶指针：链栈使用栈顶指针来指向栈顶元素，方便进行入栈、出栈、取栈顶元素等操作
操作受限：链栈只能从栈顶进行入栈和出栈操作，不能在中间插入或删除元素。这使得链栈的操作相对简单，但也带来了一定的限制

链栈的定义

// 定义链表节点
typedef struct node
{
    int data;          // 节点存储的数据
    struct node *next; // 指向下一个节点的指针
} node;

// 定义栈结构体
typedef struct stack
{
    node *top; // 栈顶指针，指向最新入栈的节点
    int size;  // 栈的大小
} stack;

链栈的初始化

// 初始化一个空栈
stack *init_stack()
{
    stack *s = (stack *)malloc(sizeof(stack)); // 动态分配内存
    s->top = NULL;                             // 栈顶指针指向空
    s->size = 0;                               // 栈大小为 0
    return s;
}

链栈的栈空

// 判断栈是否为空
int isempty_stack(stack *s)
{
    if (s->top == NULL) // 栈顶指针指向空，说明栈为空
    {
        return 1;
    }
    return 0;
}

链栈的入栈

// 入栈操作
void push_stack(stack *s, int data)
{
    node *new_node = (node *)malloc(sizeof(node)); // 动态分配内存
    new_node->data = data;                         // 新节点存储数据
    new_node->next = s->top;                       // 新节点的 next 指向原栈顶节点
    s->top = new_node;                             // 栈顶指针指向新节点
    s->size++;                                     // 栈大小加 1
}

链栈的出栈

// 出栈操作
void pop_stack(stack *s)
{
    if (isempty_stack(s)) // 栈为空
    {
        printf("栈空");
        return;
    }
    node *node = s->top; // 获取栈顶节点
    s->top = node->next; // 栈顶指针指向下一个节点
    free(node);          // 释放栈顶节点内存
    s->size--;           // 栈大小减 1
}

链栈的打印

// 打印操作
void print_stack(stack *s)
{
    // 判断栈是否为空
    if (isempty_stack(s))
    {
        printf("栈空");
        return;
    }
    // 从栈顶开始遍历栈中的元素
    node *node = s->top;
    while (node != NULL)
    {
        printf("%d ", node->data); // 打印当前节点的数据
        node = node->next;         // 移动到下一个节点
    }
    // 打印换行符
    printf("\n");
}

顺序栈与链栈的对比

顺序栈存取方便，但如果分配的容量过大，容易造成空间闲置
链栈需要为每个元素设置指针域，增加了一些内存开销，但栈中无空闲单元
当栈在使用过程中，若长度常常急剧变化的话，最好采用链栈;反之，若栈的长度变化范围不大，则宜采用顺序栈

两个彼此迎面增长的栈

两个栈共享同一个连续的存储空间
栈底分别安排在两端，两个栈彼此迎面增长
溢出发生的频率比两个栈单独安排要小得多

3.4 栈的应用举例

3.4.1 数制转换问题

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100

// 定义一个栈数据结构
typedef struct stack
{
    int *base; // 栈底指针
    int *top;  // 栈顶指针
    int size;  // 栈的大小
} stack;

// 初始化栈
void init_stack(stack *s)
{
    s->base = (int *)malloc(sizeof(int) * MAX_SIZE); // 为栈分配内存
    s->top = s->base;                                // 设置栈顶指针为栈底指针
    s->size = MAX_SIZE;                              // 设置栈的大小
}

// 判断栈是否为空
int is_empty(stack *s)
{
    if (s->base == s->top) // 如果栈底指针和栈顶指针相等，则栈为空
    {
        return 1;
    }
    return 0;
}

// 判断栈是否已满
int is_full(stack *s)
{
    if (s->top - s->base == s->size) // 如果栈顶指针减去栈底指针等于栈的大小，则栈已满
    {
        return 1;
    }
    return 0;
}

// 入栈操作
void push_stack(stack *s, int data)
{
    if (is_full(s)) // 如果栈已满，则无法入栈
        return;
    *(s->top++) = data; // 将数据存入栈顶，并将栈顶指针向上移动一位
}

// 出栈操作
void pop_stack(stack *s)
{
    if (is_empty(s)) // 如果栈为空，则无法出栈
        return;
    printf("%d", *(--s->top)); // 将栈顶数据取出，并将栈顶指针向下移动一位
}

// 将十进制数转换为八进制数
void convert(int data)
{
    stack *s = (stack *)malloc(sizeof(stack)); // 创建一个新的栈
    init_stack(s);                             // 初始化新创建的栈
    while (data)                               // 当数据不为0时，循环执行以下操作
    {
        push_stack(s, data % 8); // 将数据除以8的余数入栈
        data /= 8;               // 将数据除以8，得到新的数据继续执行循环操作
    }
    while (!is_empty(s)) // 当栈不为空时，循环执行以下操作
    {
        pop_stack(s); // 将余数从栈中取出并打印，得到八进制数的表示形式
    }
}

int main()
{
    int data;
    printf("请输入一个十进制数:");
    scanf("%d", &data);
    printf("转换为八进制为:");
    convert(data);
    return 0;
}

3.4.2 括号匹配

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100

// 定义栈结构体
typedef struct stack
{
    char *base; // 栈底指针
    char *top;  // 栈顶指针
    int size;   // 栈的大小
} stack;

// 初始化栈
void init_stack(stack *s)
{
    s->base = (char *)malloc(sizeof(char) * MAX_SIZE); // 分配内存空间
    s->top = s->base;                                  // 初始化栈顶指针
    s->size = MAX_SIZE;                                // 初始化栈的大小
}

// 判断栈是否为空
int is_empty(stack *s)
{
    if (s->base == s->top) // 如果栈底指针和栈顶指针相同，说明栈为空
    {
        return 1;
    }
    return 0;
}

// 判断栈是否已满
int is_full(stack *s)
{
    if (s->top - s->base == s->size) // 如果栈顶指针减去栈底指针等于栈的大小，说明栈已满
    {
        return 1;
    }
    return 0;
}

// 入栈操作
void push_stack(stack *s, char data)
{
    if (is_full(s)) // 如果栈已满，无法入栈
        return;
    *(s->top++) = data; // 将数据存入栈顶，并将栈顶指针上移一位
}

// 出栈操作
char pop_stack(stack *s)
{
    if (is_empty(s)) // 如果栈为空，无法出栈
        return '\0';
    return *(--s->top); // 将栈顶指针下移一位，并返回出栈的数据
}

// 检查括号是否匹配的函数
void match(char str[])
{
    stack *s = (stack *)malloc(sizeof(stack)); // 分配内存空间给栈结构体
    init_stack(s);                             // 初始化栈
    for (int i = 0; str[i] != '\0'; i++)       // 遍历字符串中的每个字符
    {
        if (str[i] == '(' || str[i] == '[' || str[i] == '{') // 如果是左括号，入栈
        {
            push_stack(s, str[i]);
        }
        else if (str[i] == ')' || str[i] == ']' || str[i] == '}') // 如果是右括号，出栈并检查是否匹配
        {
            char ch = pop_stack(s);
            if (str[i] == ')' && ch != '(') // 如果不匹配，输出“匹配失败”
            {
                printf("匹配失败");
                return;
            }

            if (str[i] == ']' && ch != '[')
            {
                printf("匹配失败");
                return;
            }
            if (str[i] == '}' && ch != '{')
            {
                printf("匹配失败");
                return;
            }
        }
    }
    if (is_empty(s)) // 如果遍历完字符串后，栈为空，说明括号匹配成功，输出“匹配成功”
    {
        printf("匹配成功");
    }
    else // 否则，输出“匹配失败”
    {
        printf("匹配失败");
    }
}

int main()
{
    char ch[10];
    gets(ch);
    match(ch);
}

3.4.3 栈与递归

递归是一种编程技巧，它指的是程序调用自身。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件满足时，递归返回；当递归条件不满足时，递归前进。递归的目的通常是把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
很多数学函数是递归定义的，如阶乘函数、阿克曼(Ackerman)函数等等;
有些数据结构，如二叉树、广义表等等，本身固有递归特性，可用递归进行描述和处理;

在这里插入图片描述

有些问题本身没有明显的递归结构，但用递归求解比迭代求解更简单，如八皇后问题、Hanoi塔等等。

在这里插入图片描述
递归求和

#include <stdio.h>

int sum(int num)
{
    if (num == 1)
    {
        return 1;
    }
    else
    {
        return num + sum(num - 1);
    }
}

int main()
{
    int num = 10;
    printf("%d", sum(num));
    return 0;
}

迭代——通过某段代码的重复执行来实现循环
递归——通过重复调用函数自身来实现循环

递归算法具有高度概括性、结构简洁、正确性易于证明等优点，但是在时空的开销上相对较大
迭代时空效率较高，运行时间只随循环次数增加而增加，没其他额外开销，空间上也没有什么增加
在追求更高效率的场合，应尽可能地避免递归，尤其是过度的递归
一般情况下，当迭代方法比较容易找到时，应该避免使用递归;反之，当很难建立一个迭代方法，或者当问题底层的数据结构本身就是递归的时，递归就是比较好的方法

3.5 链队列

定义

队列是只允许在一端删除，在另一端插入的线性表
允许删除的一端叫做队头(front)，允许插入的一端叫做队尾(rear)

特性

先进先出(FIFO,First In First Out)

存储特点:

队头在链头，队尾在链尾
设置队头、队尾指针分别保存队头、队尾地址

链队列的定义

// 定义结构体 node，表示队列中的节点
typedef struct node
{
    int data;          // 存储节点中的数据
    struct node *next; // 指向队列中下一个节点的指针
} node;

// 定义结构体 queue，表示队列
typedef struct queue
{
    node *front; // 指向队列头部的指针
    node *rear;  // 指向队列尾部的指针
} queue;

链队列的初始化

在这里插入图片描述

// 初始化队列
void init_queue(queue *s)
{
    s->front = s->rear = NULL; // 头尾指针均指向空
}

链队列为空

// 判断队列是否为空
int empty(queue *s)
{
    if (s->front == NULL)
        return 1;
    return 0;
}

链队列的入队

在这里插入图片描述

// 向队列中添加元素
void enter_queue(queue *s, int data)
{
    // 创建新的节点
    node *new_node = (node *)malloc(sizeof(node));
    new_node->data = data; // 存储新节点中的数据
    new_node->next = NULL; // 新节点的下一个节点指向空

    // 如果队列为空，将头尾指针均指向新节点
    if (empty(s))
    {
        s->front = s->rear = new_node;
    }
    else
    {
        // 如果队列不为空，将尾指针指向新节点，并更新队列的尾指针
        s->rear->next = new_node;
        s->rear = new_node;
    }
}

链队列的出队

// 从队列中取出元素
void out_queue(queue *s)
{
    if (empty(s))
        return;

    // 取出队列头部节点
    node *temp = s->front;

    // 如果队列只有一个节点，将头尾指针均指向空
    if (s->front == s->rear)
    {
        s->front = s->rear = NULL;
    }
    else
    {
        // 如果队列有多个节点，将头指针指向下一个节点
        s->front = s->front->next;
    }

    free(temp); // 释放节点内存
}

链队列的打印

// 打印队列中的元素
void print_queue(queue *s)
{
    if (empty(s))
        return;

    // 遍历队列中的节点，并输出每个节点中的数据
    node *temp = s->front;
    while (temp != NULL)
    {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

3.6 循环队列

循环队列是一种线性数据结构，它将队列的存储空间的最后一个位置绕到第一个位置，形成逻辑上的环状空间，供队列循环使用。

循环队列的定义

typedef struct queue
{
    int data[MAX_SIZE]; // 存储队列元素的数组
    int front;          // 指向队头元素的指针
    int rear;           // 指向队尾元素的指针
} queue;

循环队列队满

// 判断队列是否已满
int full_queue(queue *s)
{
    if ((s->rear + 1) % MAX_SIZE == s->front) // 队尾指针 + 1 等于队头指针时，队列已满
    {
        return 1; // 已满返回1
    }
    return 0; // 未满返回0
}

循环队列队空

// 判断队列是否为空
int empty_queue(queue *s)
{
    if (s->rear == s->front) // 队头指针等于队尾指针时，队列为空
    {
        return 1; // 空返回1
    }
    return 0; // 非空返回0
}

循环队列的初始化

// 初始化队列
void init_queue(queue *s)
{
    s->front = 0; // 队头指针初始化为0
    s->rear = 0;  // 队尾指针初始化为0
}

循环队列的入队

// 入队操作
void enter_queue(queue *s, int data)
{
    if (full_queue(s)) // 如果队列已满，直接返回
        return;
    s->data[s->rear++] = data; // 将元素添加到队尾，并将队尾指针后移
}

循环队列的出队

在这里插入图片描述

// 出队操作
void out_queue(queue *s)
{
    if (empty_queue(s)) // 如果队列为空，直接返回
        return;
    s->front = (s->front + 1) % MAX_SIZE; // 将队头指针后移一位，实现出队操作
}

循环队列的打印

// 打印队列元素
void print_queue(queue *s)
{
    int i = s->front;    // 定义一个变量i，用来遍历队列元素，初始化为队头指针
    while (i != s->rear) // 当i不等于队尾指针时，循环遍历队列元素
    {
        printf("%d ", s->data[i]); // 输出当前元素
        i = (i + 1) % MAX_SIZE;    // i后移一位，继续遍历
    }
}

总结

先入队的元素总是先出队
无论循环队列还是链队列，前述各算法的T(n)=O(1)
应用较为广泛：事件处理、任务调度、I/O

完整代码

顺序栈

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100

// 定义栈结构体
typedef struct stack
{
    int *base;      // 栈底指针
    int *top;       // 栈顶指针
    int stack_size; // 栈大小
} stack;

// 初始化栈
void init_stack(stack *s)
{
    s->base = (int *)malloc(sizeof(int) * MAX_SIZE); // 为栈分配内存空间
    s->stack_size = MAX_SIZE;                        // 初始化栈大小
    s->top = s->base;                                // 初始化栈顶指针指向栈底
}

// 判断栈是否为空
int is_empty(stack *s)
{
    if (s->base == s->top)
    {
        return 1; // 栈为空
    }
    return 0; // 栈不为空
}

// 判断栈是否已满
int is_full(stack *s)
{
    if (s->top - s->base == s->stack_size)
    {
        return 1; // 栈已满
    }
    return 0; // 栈未满
}

// 入栈操作
void push_stack(stack *s, int data)
{
    if (is_full(s))
    {
        printf("栈满"); // 栈已满，无法入栈
        return;
    }
    *(s->top++) = data; // 入栈操作
}

void pop_stack(stack *s)
{
    // 如果栈为空，则打印提示信息并直接返回
    if (is_empty(s))
    {
        printf("栈空");
        return;
    }
    s->top--;                // 栈顶指针减1，指向下一个元素
    printf("%d\n", *s->top); // 打印栈顶元素的值
}

int main()
{
    stack s;
    init_stack(&s);
    push_stack(&s, 1);
    push_stack(&s, 2);
    push_stack(&s, 3);
    pop_stack(&s);
    pop_stack(&s);
    pop_stack(&s);
    pop_stack(&s);
}

链栈

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点
typedef struct node
{
    int data;          // 节点存储的数据
    struct node *next; // 指向下一个节点的指针
} node;

// 定义栈结构体
typedef struct stack
{
    node *top; // 栈顶指针，指向最新入栈的节点
    int size;  // 栈的大小
} stack;

// 初始化一个空栈
stack *init_stack()
{
    stack *s = (stack *)malloc(sizeof(stack)); // 动态分配内存
    s->top = NULL;                             // 栈顶指针指向空
    s->size = 0;                               // 栈大小为 0
    return s;
}

// 判断栈是否为空
int isempty_stack(stack *s)
{
    if (s->top == NULL) // 栈顶指针指向空，说明栈为空
    {
        return 1;
    }
    return 0;
}

// 入栈操作
void push_stack(stack *s, int data)
{
    node *new_node = (node *)malloc(sizeof(node)); // 动态分配内存
    new_node->data = data;                         // 新节点存储数据
    new_node->next = s->top;                       // 新节点的 next 指向原栈顶节点
    s->top = new_node;                             // 栈顶指针指向新节点
    s->size++;                                     // 栈大小加 1
}

// 出栈操作
void pop_stack(stack *s)
{
    if (isempty_stack(s)) // 栈为空
    {
        printf("栈空");
        return;
    }
    node *node = s->top; // 获取栈顶节点
    s->top = node->next; // 栈顶指针指向下一个节点
    free(node);          // 释放栈顶节点内存
    s->size--;           // 栈大小减 1
}

// 打印操作
void print_stack(stack *s)
{
    // 判断栈是否为空
    if (isempty_stack(s))
    {
        printf("栈空");
        return;
    }
    // 从栈顶开始遍历栈中的元素
    node *node = s->top;
    while (node != NULL)
    {
        printf("%d ", node->data); // 打印当前节点的数据
        node = node->next;         // 移动到下一个节点
    }
    // 打印换行符
    printf("\n");
}

int main()
{
    stack *s = init_stack();
    push_stack(s, 1);
    push_stack(s, 2);
    push_stack(s, 3);
    push_stack(s, 4);
    push_stack(s, 5);
    print_stack(s);
    pop_stack(s);
    print_stack(s);
    pop_stack(s);
    pop_stack(s);
    pop_stack(s);
    pop_stack(s);
    print_stack(s);

    return 0;
}

链队列

#include <stdio.h>
#include <stdlib.h>

// 定义结构体 node，表示队列中的节点
typedef struct node
{
    int data;          // 存储节点中的数据
    struct node *next; // 指向队列中下一个节点的指针
} node;

// 定义结构体 queue，表示队列
typedef struct queue
{
    node *front; // 指向队列头部的指针
    node *rear;  // 指向队列尾部的指针
} queue;

// 初始化队列
void init_queue(queue *s)
{
    s->front = s->rear = NULL; // 头尾指针均指向空
}

// 判断队列是否为空
int empty(queue *s)
{
    if (s->front == NULL)
        return 1;
    return 0;
}

// 向队列中添加元素
void enter_queue(queue *s, int data)
{
    // 创建新的节点
    node *new_node = (node *)malloc(sizeof(node));
    new_node->data = data; // 存储新节点中的数据
    new_node->next = NULL; // 新节点的下一个节点指向空

    // 如果队列为空，将头尾指针均指向新节点
    if (empty(s))
    {
        s->front = s->rear = new_node;
    }
    else
    {
        // 如果队列不为空，将尾指针指向新节点，并更新队列的尾指针
        s->rear->next = new_node;
        s->rear = new_node;
    }
}

// 从队列中取出元素
void out_queue(queue *s)
{
    if (empty(s))
        return;

    // 取出队列头部节点
    node *temp = s->front;

    // 如果队列只有一个节点，将头尾指针均指向空
    if (s->front == s->rear)
    {
        s->front = s->rear = NULL;
    }
    else
    {
        // 如果队列有多个节点，将头指针指向下一个节点
        s->front = s->front->next;
    }

    free(temp); // 释放节点内存
}

// 打印队列中的元素
void print_queue(queue *s)
{
    if (empty(s))
        return;

    // 遍历队列中的节点，并输出每个节点中的数据
    node *temp = s->front;
    while (temp != NULL)
    {
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

int main()
{
    queue *s = (queue *)malloc(sizeof(queue)); // 创建队列指针
    init_queue(s);                             // 初始化队列
    enter_queue(s, 1);                         // 向队列中添加元素
    enter_queue(s, 2);
    enter_queue(s, 3);
    out_queue(s);   // 从队列中取出元素
    print_queue(s); // 打印队列中的元素
    return 0;
}

循环队列

#include <stdio.h>
#include <stdlib.h>

// 定义队列结构体，包含一个数组和两个指针（队头和队尾）
#define MAX_SIZE 100 // 定义数组的最大长度

typedef struct queue
{
    int data[MAX_SIZE]; // 存储队列元素的数组
    int front;          // 指向队头元素的指针
    int rear;           // 指向队尾元素的指针
} queue;

// 判断队列是否已满
int full_queue(queue *s)
{
    if ((s->rear + 1) % MAX_SIZE == s->front) // 队尾指针 + 1 等于队头指针时，队列已满
    {
        return 1; // 已满返回1
    }
    return 0; // 未满返回0
}

// 判断队列是否为空
int empty_queue(queue *s)
{
    if (s->rear == s->front) // 队头指针等于队尾指针时，队列为空
    {
        return 1; // 空返回1
    }
    return 0; // 非空返回0
}

// 初始化队列
void init_queue(queue *s)
{
    s->front = 0; // 队头指针初始化为0
    s->rear = 0;  // 队尾指针初始化为0
}

// 入队操作
void enter_queue(queue *s, int data)
{
    if (full_queue(s)) // 如果队列已满，直接返回
        return;
    s->data[s->rear++] = data; // 将元素添加到队尾，并将队尾指针后移
}

// 出队操作
void out_queue(queue *s)
{
    if (empty_queue(s)) // 如果队列为空，直接返回
        return;
    s->front = (s->front + 1) % MAX_SIZE; // 将队头指针后移一位，实现出队操作
}

// 打印队列元素
void print_queue(queue *s)
{
    int i = s->front;    // 定义一个变量i，用来遍历队列元素，初始化为队头指针
    while (i != s->rear) // 当i不等于队尾指针时，循环遍历队列元素
    {
        printf("%d ", s->data[i]); // 输出当前元素
        i = (i + 1) % MAX_SIZE;    // i后移一位，继续遍历
    }
}

int main()
{
    // 动态分配一个队列结构体的内存
    queue *s = (queue *)malloc(sizeof(queue));
    // 初始化队列
    init_queue(s);
    // 将1入队
    enter_queue(s, 1);
    enter_queue(s, 2);
    enter_queue(s, 3);
    out_queue(s);
    // 打印队列元素
    print_queue(s);

    // 释放动态分配的内存
    free(s);
    return 0;
}

汽水汽水

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
（Data Structure）数据结构第三章栈和队列

/ 定义栈结构体 typedef struct stack {int * base;// 栈底指针 int * top;// 栈顶指针 int stack_size;// 栈大小 } stack;// 定义链表节点 typedef struct node {int data;// 节点存储的数据 struct node * next;// 指向下一个节点的指针 } node;// 定义栈结构体 typedef struct stack {node * top;
复制链接

扫一扫