【数据结构】队列知识点总结--定义；基本操作；队列的顺序实现；链式存储；双端队列；循环队列

已于 2023-09-12 11:57:58 修改
阅读量867 收藏 6
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 队列 双端队列 循环队列 队列的顺序实现和链式存储
于 2023-09-12 07:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52442214/article/details/132775361
版权

 欢迎各位看官^_^

目录

1.队列的定义

2.队列的基本操作

2.1初始化队列

2.2判断队列是否为空

2.3判断队列是否已满

2.4入队

2.5出队

2.6完整代码 

3.队列的顺序实现

4.队列的链式存储

5.双端队列

6.循环队列

1.队列的定义

        队列（Queue）是一种先进先出（First In First Out，FIFO）的线性数据结构，它只允许在队尾添加元素，在队头删除元素，不支持随机访问。队列常用的操作有入队（enqueue）、出队（dequeue）、队列长度（size）、队列是否为空（empty）等。队列可以用来实现很多算法，如广度优先搜索算法（BFS）和消息传递等。

2.队列的基本操作

2.1初始化队列

        可以使用数组或链表来实现队列。对于数组，我们可以定义一个数组和两个指针（front和rear）来表示队列。对于链表，我们可以创建一个链表，并定义头节点指针和尾节点指针。队列是一种线性数据结构，可以用数组或链表来实现。

以下是用数组实现队列的C语言代码示例：

#include <stdio.h>

#define MAX_SIZE 100

int queue[MAX_SIZE];
int front = 0, rear = -1;

void enqueue(int data) {
    if (rear == MAX_SIZE - 1) {
        printf("Queue overflow\n");
    } else {
        rear++;
        queue[rear] = data;
    }
}

int dequeue() {
    if (front > rear) {
        printf("Queue underflow\n");
        return -1;
    } else {
        int data = queue[front];
        front++;
        return data;
    }
}

int main() {
    enqueue(10);
    enqueue(20);
    enqueue(30);
    printf("%d ", dequeue());
    printf("%d ", dequeue());
    printf("%d ", dequeue());
    printf("%d ", dequeue());
    return 0;
}

        上述代码中，`queue`为数组，`front`和`rear`分别表示队列的前后指针，初始化为`0`和`-1`。`enqueue`函数用于向队列中添加元素，先判断队列是否已满，若未满则将数据存入队列尾部。`dequeue`函数用于弹出队列头部元素，先判断队列是否为空，若非空则返回队列头部元素并将`front`指针后移一位。在`main`函数中，先将元素10、20、30添加到队列中，然后依次弹出队列头部元素并输出。

2.2判断队列是否为空

如果队列为空，则front和rear指向同一个位置。

// 判断队列是否为空
int is_empty() {
    return front == rear;
}

2.3判断队列是否已满

如果队列已满，则rear指向的下一个位置就是front（因为它是循环队列）。

// 判断队列是否已满
int is_full() {
    return (rear + 1) % MAX_SIZE == front;
}

2.4入队

当队列不满时，我们将元素插入队列的rear位置，并将rear指针后移。

// 入队
void enqueue(int data) {
    if (is_full()) {
        printf("Queue is full.\n");
        return;
    }
    queue[rear] = data;
    rear = (rear + 1) % MAX_SIZE;
}

2.5出队

当队列不为空时，我们将front指向的元素从队列中删除，并将front指针后移。

// 出队
int dequeue() {
    if (is_empty()) {
        printf("Queue is empty.\n");
        return -1;
    }
    int data = queue[front];
    front = (front + 1) % MAX_SIZE;
    return data;
}

2.6完整代码 

#include <stdio.h>
#define MAX_SIZE 10      // 定义队列的最大容量为10

int queue[MAX_SIZE];     // 定义数组队列
int front = 0, rear = 0; // front指向队首，rear指向队尾的下一个位置

// 判断队列是否为空
int is_empty() {
    return front == rear;
}

// 判断队列是否已满
int is_full() {
    return (rear + 1) % MAX_SIZE == front;
}

// 入队
void enqueue(int data) {
    if (is_full()) {
        printf("Queue is full.\n");
        return;
    }
    queue[rear] = data;
    rear = (rear + 1) % MAX_SIZE;
}

// 出队
int dequeue() {
    if (is_empty()) {
        printf("Queue is empty.\n");
        return -1;
    }
    int data = queue[front];
    front = (front + 1) % MAX_SIZE;
    return data;
}

int main() {
    enqueue(1);
    enqueue(2);
    enqueue(3);
    printf("%d\n", dequeue());
    printf("%d\n", dequeue());
    enqueue(4);
    printf("%d\n", dequeue());
    printf("%d\n", dequeue());
    return 0;
}

        注意：这是一个循环队列，在计算rear的位置时需要使用取模运算。这是因为数组的最后一个位置后面没有下一个位置，我们需要将rear回到数组的开头位置。 

3.队列的顺序实现

C语言队列的顺序实现可以使用数组来实现。实现思路如下：

  1. 定义一个数组和队列头尾指针。
  2. 队列头指针指向队列的第一个元素，队列尾指针指向队列的最后一个元素。
  3. 入队操作时，先判断队列是否已满，如果已满则提示队列已满，否则将元素加入到队列尾部，并更新队列尾指针。
  4. 出队操作时，先判断队列是否为空，如果为空则提示队列为空，否则将队列头部的元素出队，并更新队列头指针。
  5. 获取队列头元素时，先判断队列是否为空，如果为空则提示队列为空，否则返回队列头的元素。

以下是C语言队列的顺序实现示例代码：

#include <stdio.h>
#define MAX_SIZE 100

// 定义队列结构体
typedef struct {
    int data[MAX_SIZE];  // 存储队列的数组
    int front;  // 队列头指针
    int rear;   // 队列尾指针
} Queue;

// 初始化队列
void initQueue(Queue *q) {
    q->front = q->rear = 0;
}

// 入队
void enqueue(Queue *q, int x) {
    if ((q->rear + 1) % MAX_SIZE == q->front) {
        printf("Queue is full.\n");
    } else {
        q->data[q->rear] = x;
        q->rear = (q->rear + 1) % MAX_SIZE;
    }
}

// 出队
void dequeue(Queue *q) {
    if (q->front == q->rear) {
        printf("Queue is empty.\n");
    } else {
        q->front = (q->front + 1) % MAX_SIZE;
    }
}

// 获取队列头元素
int front(Queue *q) {
    if (q->front == q->rear) {
        printf("Queue is empty.\n");
        return -1;
    } else {
        return q->data[q->front];
    }
}

// 判断队列是否为空
int isEmpty(Queue *q) {
    return q->front == q->rear;
}

int main() {
    Queue q;
    initQueue(&q);

    // 入队
    enqueue(&q, 1);
    enqueue(&q, 2);
    enqueue(&q, 3);

    // 获取队列头元素
    printf("Front of queue: %d\n", front(&q));

    // 出队
    dequeue(&q);

    // 获取队列头元素
    printf("Front of queue: %d\n", front(&q));

    return 0;
}

 

4.队列的链式存储

        队列和链表的关系：队列和链表是两种不同的数据结构，但是在实现队列时可以使用链表来表示。队列是一种先进先出（First In First Out，FIFO）的数据结构，可以理解为是一条通道，从一端（队尾）加入数据，从另一端（队头）取出数据。而链表是一种动态数据结构，由节点之间的指针连接而成。每个节点包含一个数据元素和一个指向下一个节点的指针。在使用链表实现队列时，可以将链表的头作为队列的队头，将链表的尾作为队列的队尾，使用链表的头插法或尾插法对队列进行入队操作，使用链表的尾删除或头删除对队列进行出队操作。因此，可以说队列和链表有一定的关系，但二者仍然是不同的数据结构。 

        队列的链式存储是使用链表来实现队列的存储结构。队列的链式存储结构可以分为单向链表和双向链表两种。

        单向链表的存储结构是每个节点包含一个数据元素和一个指向下一个节点的指针。队列的头指针指向链表的头节点，队列的尾指针指向链表的尾节点。入队操作将元素添加到尾节点之后，出队操作则删除头节点。

        双向链表的存储结构是每个节点包含一个数据元素、一个指向前一个节点的指针和一个指向下一个节点的指针。队列的头指针指向链表头部，队列的尾指针指向链表尾部。入队操作将元素添加到尾节点之后，出队操作则删除头节点。

        链式存储相比于顺序存储的优势在于可以更灵活地插入和删除元素，但是在访问元素时需要通过指针遍历链表，效率较低。

        链式存储结构的队列通常包含一个头结点和一个尾结点，其中头结点指向队列的头部，尾结点指向队列的尾部。每个结点都包含一个数据域和一个指针域，指针域指向下一个结点。

以下是C语言实现队列的链式存储的示例代码：

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

// 队列结点定义
typedef struct queue_node{
    int data;                   // 数据域
    struct queue_node *next;    // 指针域
} queue_node;

// 队列定义
typedef struct {
    queue_node *front;          // 队列头指针
    queue_node *rear;           // 队列尾指针
} queue;

// 初始化队列
void init_queue(queue *q)
{
    // 分配头结点
    q->front = q->rear = (queue_node *)malloc(sizeof(queue_node));
    if (!q->front) {
        printf("Memory allocation failed.\n");
        exit(-1);
    }
    q->front->next = NULL;
}

// 判断队列是否为空
int is_empty(queue *q)
{
    return q->front == q->rear;
}

// 入队
void enqueue(queue *q, int data)
{
    queue_node *new_node = (queue_node *)malloc(sizeof(queue_node));
    if (!new_node) {
        printf("Memory allocation failed.\n");
        exit(-1);
    }
    new_node->data = data;
    new_node->next = NULL;
    q->rear->next = new_node;
    q->rear = new_node;
}

// 出队
int dequeue(queue *q)
{
    if (is_empty(q)) {
        printf("Queue is empty.\n");
        exit(-1);
    }
    queue_node *p = q->front->next;
    int data = p->data;
    q->front->next = p->next;
    if (q->rear == p) {
        q->rear = q->front;
    }
    free(p);
    return data;
}

// 输出队列中元素
void print_queue(queue *q)
{
    queue_node *p = q->front->next;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main()
{
    queue q;
    init_queue(&q);
    for (int i = 1; i <= 5; i++) {
        enqueue(&q, i);
    }
    print_queue(&q);
    dequeue(&q);
    print_queue(&q);
    return 0;
}

5.双端队列

        双端队列（deque，全名double-ended queue）是一种具有队列和栈的性质的数据结构，即两端都可以进行插入和删除操作。

        双端队列有两个端点：一个是“前端”（front），可以进行“出队”操作；另一个是“后端”（rear），可以进行“入队”操作。因此，双端队列支持的操作包括入队、出队、队头入队、队尾入队、队头出队、队尾出队等。

        与单端队列相比，双端队列的优势在于可以自由地从两端添加或删除元素，更加灵活、方便地实现某些算法和数据结构。例如，在实现图遍历算法中，使用双端队列可以使得遍历的顺序更加合理，减少搜索的时间和空间复杂度。

        另外，双端队列支持一些其他的操作，如获取队列长度、获取队头/尾元素等。

以下是C语言实现双端队列的代码：

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

// 双端队列节点结构体
typedef struct DequeNode {
    int val;
    struct DequeNode* next;
    struct DequeNode* prev;
} DequeNode;

// 双端队列结构体
typedef struct Deque {
    DequeNode* front; // 队头指针
    DequeNode* rear; // 队尾指针
    int size; // 队列元素个数
} Deque;

// 初始化双端队列
void initDeque(Deque* deque) {
    deque->front = NULL;
    deque->rear = NULL;
    deque->size = 0;
}

// 判断双端队列是否为空
bool isEmptyDeque(Deque* deque) {
    return deque->size == 0;
}

// 获取双端队列的长度
int sizeDeque(Deque* deque) {
    return deque->size;
}

// 获取双端队列队头元素
int frontDeque(Deque* deque) {
    return deque->front->val;
}

// 获取双端队列队尾元素
int rearDeque(Deque* deque) {
    return deque->rear->val;
}

// 在双端队列前端插入元素
void addFrontDeque(Deque* deque, int val) {
    DequeNode* new_node = (DequeNode*)malloc(sizeof(DequeNode));
    new_node->val = val;
    new_node->next = deque->front;
    new_node->prev = NULL;
    if (deque->front != NULL) {
        deque->front->prev = new_node;
    }
    deque->front = new_node;
    if (deque->rear == NULL) {
        deque->rear = new_node;
    }
    deque->size++;
}

// 在双端队列后端插入元素
void addRearDeque(Deque* deque, int val) {
    DequeNode* new_node = (DequeNode*)malloc(sizeof(DequeNode));
    new_node->val = val;
    new_node->next = NULL;
    new_node->prev = deque->rear;
    if (deque->rear != NULL) {
        deque->rear->next = new_node;
    }
    deque->rear = new_node;
    if (deque->front == NULL) {
        deque->front = new_node;
    }
    deque->size++;
}

// 在双端队列前端删除元素
void removeFrontDeque(Deque* deque) {
    if (deque->front == NULL) {
        return;
    }
    DequeNode* temp = deque->front;
    deque->front = deque->front->next;
    if (deque->front != NULL) {
        deque->front->prev = NULL;
    } else {
        deque->rear = NULL;
    }
    free(temp);
    deque->size--;
}

// 在双端队列后端删除元素
void removeRearDeque(Deque* deque) {
    if (deque->rear == NULL) {
        return;
    }
    DequeNode* temp = deque->rear;
    deque->rear = deque->rear->prev;
    if (deque->rear != NULL) {
        deque->rear->next = NULL;
    } else {
        deque->front = NULL;
    }
    free(temp);
    deque->size--;
}

// 测试
int main() {
    Deque deque;
    initDeque(&deque);
    addFrontDeque(&deque, 1);
    addRearDeque(&deque, 2);
    addFrontDeque(&deque, 3);
    addRearDeque(&deque, 4);
    while (!isEmptyDeque(&deque)) {
        printf("%d ", frontDeque(&deque));
        removeFrontDeque(&deque);
    }
    printf("\n");
    return 0;
}

6.循环队列

        循环队列是一种环形数据结构，它允许在一端添加数据元素，同时在另一端删除数据元素。与线性队列不同的是，在循环队列中，队头和队尾是可以相互穿越的。这意味着队列的末尾可以连接到队列的开始，形成一个环。这样，可以使用有限的空间，存储无限数量的数据元素。

        循环队列通常使用数组来实现。它有一个前后指针，称为队头和队尾。入队操作时，将新元素加入队尾，并将队尾指针向后移动。出队操作时，将队头元素删除，并将队头指针向后移动。当队列满时，新元素无法插入，即使队列前面有空位置。当队列为空时，无法删除元素。

        循环队列的主要优点是可以避免队列的前面空出大量空间，同时保证队列的顺序性和完整性。缺点是在实现时需要注意控制队列满和空的情况，以及指针的计算。

        循环队列是一种特殊的队列，其队尾指针指向数组的末尾后会回到数组的开头，实现队列的循环利用。下面是C语言实现循环队列的示例代码：

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

#define QUEUE_MAX_SIZE 5  // 队列的最大容量

typedef struct {
    int* data;  // 队列数据存储的位置
    int front;  // 队首指针
    int rear;   // 队尾指针
} Queue;

// 初始化队列
void InitQueue(Queue* q) {
    q->data = (int*)malloc(QUEUE_MAX_SIZE * sizeof(int));  // 分配队列空间
    q->front = q->rear = 0;  // 初始化队首和队尾指针
}

// 判断队列是否为空
int IsEmpty(Queue* q) {
    return q->front == q->rear;
}

// 判断队列是否已满
int IsFull(Queue* q) {
    return (q->rear + 1) % QUEUE_MAX_SIZE == q->front;
}

// 入队操作
int EnQueue(Queue* q, int value) {
    if (IsFull(q)) {
        return 0;  // 队列已满，无法入队
    }
    q->data[q->rear] = value;  // 将数据存入队列
    q->rear = (q->rear + 1) % QUEUE_MAX_SIZE;  // 队尾指针后移
    return 1;  // 入队成功
}

// 出队操作
int DeQueue(Queue* q, int* value) {
    if (IsEmpty(q)) {
        return 0;  // 队列为空，无法出队
    }
    *value = q->data[q->front];  // 取出队首数据
    q->front = (q->front + 1) % QUEUE_MAX_SIZE;  // 队首指针后移
    return 1;  // 出队成功
}

// 获取队首元素
int GetFront(Queue* q, int* value) {
    if (IsEmpty(q)) {
        return 0;  // 队列为空，无法获取队首元素
    }
    *value = q->data[q->front];  // 获取队首元素
    return 1;  // 获取成功
}

// 获取队列长度
int GetLength(Queue* q) {
    return (q->rear - q->front + QUEUE_MAX_SIZE) % QUEUE_MAX_SIZE;
}

// 输出队列中的所有元素
void PrintQueue(Queue* q) {
    int i, len = GetLength(q);
    for (i = 0; i < len; i++) {
        int value;
        DeQueue(q, &value);
        printf("%d ", value);
        EnQueue(q, value);
    }
    printf("\n");
}

// 测试代码
int main() {
    Queue q;
    InitQueue(&q);
    EnQueue(&q, 1);
    EnQueue(&q, 2);
    EnQueue(&q, 3);
    EnQueue(&q, 4);
    EnQueue(&q, 5);
    printf("Queue length: %d\n", GetLength(&q));  // 5
    printf("Queue content: ");
    PrintQueue(&q);  // 1 2 3 4 5
    int value;
    DeQueue(&q, &value);
    printf("DeQueue value: %d\n", value);  // 1
    printf("Queue content: ");
    PrintQueue(&q);  // 2 3 4 5
    EnQueue(&q

        在上面的代码中，我们实现了循环队列的初始化、判断是否为空或已满、入队、出队、获取队首元素、获取队列长度和输出队列中的所有元素等操作。我们可以通过这些操作对循环队列进行基本的操作。 

 🤞❤️🤞❤️🤞❤️队列的知识点总结就到这里啦，如果对博文还满意的话，劳烦各位看官动动“发财的小手”留下您对博文的赞和对博主的关注吧🤞❤️🤞❤️🤞❤️

十三衙
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
队列的知识点总结
Lookdrama的博客
10-30 518
一个“先进先出”的数据结构。队列是一种只允许在一段进行删除操作，在另一端进行插入操作的线性表。
数据结构——队列
qq_73201597的博客
03-30 242
队列的容量有限：队列的容量是有限的，即队列能够容纳的元素数量是有限的。队列的头部保存的是最先进入的元素，而队列的尾部保存的是最后进入的元素。队列的插入和删除操作的时间复杂度都为O(1)，但在使用数组实现的队列中，插入和删除操作可能会导致元素的移动，造成额外的时间和空间开销。队列的数据存储必须是顺序的：队列只能在队列的头部删除元素，在队列的尾部添加元素，数据的存储必须是顺序的，不适合随机访问和修改数据。队列的检索操作效率较低：在使用数组实现的队列中，查找队列中某个元素的效率较低，需要遍历整个队列来查找。
队列的链式存储结构
ana35287的博客
01-23 337
队列的链式存储结构 所谓队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已。 为了操作方便，我们将队头指针指向链队列的头结点，而队尾指针指向终点元素，注意这个时候不是尾部元素的下一个了。如图： 空队列时，头指针front和尾指针rear都指向头结点。 链队列的结构为 1 typedef struct QNode //节点结构 2 { 3 ...
C语言 队列（循环队列和链队初始化进出队等基本操作）
热门推荐
m0_73070900的博客
04-23 1万+
循环队列、链队的初始化、进队和出队等基本操作-----
数据结构：队列——队列的概念、顺序和链式存储的实现
仔仔木的博客
07-27 936
intfront,rear;//队头指针和队尾指针。intfront,rear;//队头指针和队尾指针。ElemTypedata[MaxSize];ElemTypedata[MaxSize];来区分栈空和栈满,这个空间并不是指特定的，只是在队头和队尾之间留一个空。队列也是一种受限的线性表，只允许一端插入，另一端删除。队空rear==front&&tag==0。队满rear==front&&tag==1。//表示队中成员个数。队满size=maxsize。...............
数据结构-队列详解（类C语言版）
秃了也弱了
04-10 2357
目录 队列的相关概念 定义 逻辑结构 存储结构 运算规则 实现方式 队列的基本操作 循环队列——队列的顺序表示和实现 队列的顺序存储结构 假溢出-引出循环队列 判断循环队列队空队满 循环队列的操作 队列的初始化 求循环队列长度 循环队列入队 循环队列出队 取循环队列队头元素 队列-链式队列 队列的链式存储结构 链队列的类型定义 链式队列的操作 链队的初始化 链队的入队 链队的出队 取链队的队头元素 销毁链队列 队列的相关概念 定义 只能在表...
数据结构--队列--思维导图.pdf
08-29
双端队列可以按照顺序存储或链式存储方式存储。 队列的应用 队列有广泛的应用，如： 1. 层次遍历 2. 计算机系统 队列是一种重要的抽象数据类型，具有重要的应用价值。了解队列的基本概念和操作对于学习数据结构...
数据结构-实验4-循环队列的实现和运算.docx
07-12
循环队列的实现强化了对线性表操作的理解，特别是链式存储结构，同时，也锻炼了编程能力和问题解决能力。在后续的学习和工作中，循环队列作为一种基础数据结构，将继续在算法设计、操作系统调度、网络协议等方面发挥...
作业 第三章 栈和队列 顺序存储结构和链式存储结构
最新发布
04-20
本章主要探讨的是两种常用且基础的数据结构——栈（Stack）和队列（Queue），以及它们的两种基本存储方式：顺序存储结构（Sequential Storage Structure）和链式存储结构（Linked Storage Structure）。我们将深入...
数据结构第三章栈和队列3.1-3.2
11-23
3.1_1栈的基本概念.mp4将介绍栈的基本概念，3.1_2栈的顺序存储实现.mp4和3.1_3栈的链式存储实现.mp4则会分别讲解栈的两种常见实现方式——顺序存储和链式存储，它们各有优劣，适用于不同的情况。 接下来，我们转向...
实验报告栈和队列的操作实验报告
04-25
栈，队列，循环队列； 数据结构实验报告，循环队列打印杨辉三角
数据结构循环队列的基本操作
02-01
数据结构中循环队列的基本操作，分享一下，欢迎大家批评指正！
数据结构入门——队列的实现.rar
04-02
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和操作数据。在这个"数据结构入门——队列的实现.rar"的压缩包中，我们主要关注的是队列这一基础但重要的数据结构。队列，正如其名，模拟了现实生活中的...
数据结构：队列的基本操作
m0_51148715的博客
02-07 8007
队列是一种先进先出（First in First Out）的线性表，简称FIFO。与栈不同，栈是一种后进先出（先进后出）的线性表。在队列中，允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q=（a1,a2,…,an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然在队伍的最后。队列分为顺序队列和循环队列。顺序队列我们可以利用数组或者链表实现。这里，我们选择用链表实现顺序队列。 链
数据结构之队（循环队列）的基本操作和实现
BaoITcore的博客
11-13 6192
引言：这篇文章的末尾有完整的实现代码，前面还是先进行分步实现，即我们探讨一下为什么要这样做，以及我们应该怎么样一步一步的实现循环队列。 目录 一、队列的概念 二、队的基本操作 三、对于队的操作，了解若干个规则 四、对队列的基本操作进行实现 （1）、队的初始化 （2）、判断队是否为空 （3）、求队列的长度 （4）、入队操作 （5）、出队操作 （6）、求队首元素 （7）、主函数 （8）、运行结果 （9）、完整代码 总结 一、队列的概念 我们可以把队列理解...
顺序队列及链队列的基本操作实现
IMIS_TwentyEight的博客
10-24 2003
队列的顺序存储结构和链式存储结构
队列的基本操作
麻辣清汤的博客
09-14 1万+
队列是一个插入操作和删除操作受到限制的线性表数据结构 队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另端进行，因此队列又称先进先出表 　　（1）允许删除的一端称为队头（Front）。 　　（2）允许插入的一端称为队尾（Rear）。 　　（3）当队列中没有元素时称为空队列。 　　（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。 　队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（即不允许"加塞"...
【数据结构】线性表（八）队列：顺序队列及其基本操作（初始化、判空、判满、入队、出队、存取队首元素）
天地玄黄 魑魅魍魉 风花雪月 商角徵羽 暂时停更 十月重见
10-21 1299
本文实现了一个基本的顺序队列，包括队列的初始化、判空、判满、入队、出队和获取队首元素等操作。
队列基本操作总结
HanSion.Z
08-13 4886
定义数据结构 typedef int DataType; //定义队列结点类型 typedef struct QueueNode { struct QueueNode* _next; DataType _data; }QueueNode; //定义队列类型 typedef struct Queue { QueueNode* front;//队头 QueueNo...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十三衙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值