数据结构——队列

最新推荐文章于 2024-08-29 18:01:01 发布
最新推荐文章于 2024-08-29 18:01:01 发布
阅读量479 收藏 5
点赞数 8
文章标签： 数据结构 c语言 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78622258/article/details/141516055
版权

 1.队列

是一种先进先出（FIFO，LILO）的数据结构，它允许在一端进行插入（入队），在另外一端进行删除（出队）

插入（入队）：队尾

删除（出队）：队头

头指针：指针非彼指针，既可以是整型的数据，也可以是真正的指针，它指向队列的头部

尾指针：指针非彼指针，既可以是整型的数据，也可以是真正的指针，它指向队列的尾部

  • 队列的基本的操作：

    （1）创建队列

    创建顺序队列（常用）

    创建链式队列

    （2）入队

    （3）出队

    （4）判空

    （5）判满

     
  • 队列是只允许在一端进行插入操作，在另外一端进行操作的线性表。
  • 队列特点：先进先出，后进后出（这种形式称之为：FIFO）
  • 队列的操作：
    1. 入队
    2. 出队
  • 进行插入操作的那一端称之为队尾，进行删除的那一端称之为队头

1、顺序队列 

 

//顺序队列
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#define MAX 20
struct queue
{
	int queue[MAX];
	int head;//头指针
	int tail;//尾指针
};
//创建队列
struct queue *Queue_creat()
{
	struct queue*P=(struct queue*)malloc(sizeof(struct queue));
	if(P==NULL)
	{
		printf("创建队列失败\n");
		return NULL;
	}
	memset(P->queue,0,sizeof(P->queue));
	P->head=0;
	P->tail=0;
	return P;
}
//判空
bool Queue_Empty(struct queue *P)
{
	if(P->head==P->tail)
	{
		printf("队列为空\n");
		return true;
	}
	return false;
}
//判满
bool Queue_Full(struct queue*P)//这里有假溢出的情况，所以使用队列时一般使用循环队列
{
	if(P->tail==MAX-1)
	{
		printf("队列已满\n");
		return true;
	}
	return false;
}
//入队
bool Queue_Insert(struct queue*P,int value)
{
	if(Queue_Full(P))
	{
		printf("队列已满,入队失败\n");
		return false;
	}
	struct queue*node=P;
	node->queue[node->tail]=value;
	node->tail++;
	return true;
}
//出队
bool Queue_Out(struct queue*P,int *value)
{
	if(Queue_Empty(P))
	{
		printf("队列为空，出队失败\n");
		return false;
	}
	struct queue*node=P;
	*value=node->queue[P->head];
	node->queue[P->head]=0;//出队之后，将出队的元素赋值为0
	P->head++;
	return true;
};
int main(int argc, const char *argv[])
{
	int value;
	struct queue *P=Queue_creat();
	Queue_Insert(P,1);
	Queue_Insert(P,2);
	Queue_Insert(P,3);
	Queue_Insert(P,4);
	Queue_Insert(P,5);
	Queue_Out(P,&value);
	printf("value=%d\n",value);
	Queue_Out(P,&value);
	printf("value=%d\n",value);
		
	return 0;
}

2、链式队列 

 

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

// 定义结点
struct node {
    int data;  // 数据域
    struct node *next;  // 指针域
};

// 定义队列指针
struct queue {
    struct node *head;  // 头指针
    struct node *tail;  // 尾指针
};

// 创建队列
struct queue *Queue_create() {
    struct queue *queue = (struct queue *)malloc(sizeof(struct queue));
    if (queue == NULL) {
        printf("创建队列失败\n");
        return NULL;
    }
    queue->head = queue->tail = NULL;
    return queue;
}

// 判空
bool Queue_Empty(struct queue *queue) {
    return queue->head == NULL;
}

// 入队
bool Queue_Insert(struct queue *queue, int value) {
    struct node *node = (struct node *)malloc(sizeof(struct node));
    if (node == NULL) {
        printf("创建结点失败\n");
        return false;
    }
    node->data = value;
    node->next = NULL;
    if (Queue_Empty(queue)) {
        queue->head = queue->tail = node;
    } else {
        queue->tail->next = node;
        queue->tail = node;
    }
    return true;
}

// 出队
bool Queue_Out(struct queue *queue, int *value) {
    if (Queue_Empty(queue)) {
        printf("队列为空，出队失败\n");
        return false;
    }
    struct node *temp = queue->head;
    *value = temp->data;
    queue->head = queue->head->next;
    if (queue->head == NULL) {  // 如果队列为空
        queue->tail = NULL;
    }
    free(temp);
    return true;
}

int main(int argc, const char *argv[]) {
    int value;
    struct queue *P = Queue_create();
    if (P == NULL) return -1;
    
    Queue_Insert(P, 1);
    Queue_Insert(P, 2);
    Queue_Insert(P, 3);
    Queue_Insert(P, 4);
    Queue_Insert(P, 5);
    
    if (Queue_Out(P, &value)) {
        printf("value=%d\n", value);
    }
    if (Queue_Out(P, &value)) {
        printf("value=%d\n", value);
    }
    
    // 释放队列内存
    while (!Queue_Empty(P)) {
        Queue_Out(P, &value);
    }
    free(P);
    
    return 0;
}

3、循环队列

解决假溢出问题，

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

// 定义队列的最大长度
#define MAX_SIZE 5

// 定义循环队列结构
struct CircularQueue {
    int data[MAX_SIZE];  // 队列数组
    int front;  // 队头指针
    int rear;   // 队尾指针
};

// 创建循环队列
struct CircularQueue* createQueue() {
    struct CircularQueue *queue = (struct CircularQueue *)malloc(sizeof(struct CircularQueue));
    if (queue == NULL) {
        printf("内存分配失败\n");
        return NULL;
    }
    queue->front = queue->rear = 0;  // 初始化队头和队尾指针
    return queue;
}

// 判空
bool isEmpty(struct CircularQueue *queue) {
    return queue->front == queue->rear;
}

// 判满
bool isFull(struct CircularQueue *queue) {
    return (queue->rear + 1) % MAX_SIZE == queue->front;
}

// 入队
bool enqueue(struct CircularQueue *queue, int value) {
    if (isFull(queue)) {
        printf("队列已满，入队失败\n");
        return false;
    }
    queue->data[queue->rear] = value;
    queue->rear = (queue->rear + 1) % MAX_SIZE;  // 更新队尾指针
    return true;
}

// 出队
bool dequeue(struct CircularQueue *queue, int *value) {
    if (isEmpty(queue)) {
        printf("队列为空，出队失败\n");
        return false;
    }
    *value = queue->data[queue->front];
    queue->front = (queue->front + 1) % MAX_SIZE;  // 更新队头指针
    return true;
}

// 获取队列中的元素个数
int queueSize(struct CircularQueue *queue) {
    return (queue->rear - queue->front + MAX_SIZE) % MAX_SIZE;
}

// 打印队列中的元素
void printQueue(struct CircularQueue *queue) {
    if (isEmpty(queue)) {
        printf("队列为空\n");
        return;
    }
    int i = queue->front;
    while (i != queue->rear) {
        printf("%d ", queue->data[i]);
        i = (i + 1) % MAX_SIZE;
    }
    printf("\n");
}

int main() {
    struct CircularQueue *queue = createQueue();

    enqueue(queue, 1);
    enqueue(queue, 2);
    enqueue(queue, 3);
    enqueue(queue, 4);
    printQueue(queue);  // 输出: 1 2 3 4

    int value;
    dequeue(queue, &value);
    printf("出队元素: %d\n", value);  // 输出: 1

    enqueue(queue, 5);
    enqueue(queue, 6);  // 队列满，无法插入

    printQueue(queue);  // 输出: 2 3 4 5

    return 0;
}

 4、双端队列

是指可以在队列的两端进行插入和删除操作，即一端既可以进行插入也可以进行删除操作，另外一端也是如此

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

#define MAX_SIZE 5  // 双端队列的最大容量

// 定义双端队列结构
struct Deque {
    int data[MAX_SIZE];  // 队列数组
    int front;  // 队头指针
    int rear;   // 队尾指针
};

// 创建双端队列
struct Deque* createDeque() {
    struct Deque *deque = (struct Deque *)malloc(sizeof(struct Deque));
    if (deque == NULL) {
        printf("内存分配失败\n");
        return NULL;
    }
    deque->front = 0;
    deque->rear = 0;
    return deque;
}

// 判空
bool isEmpty(struct Deque *deque) {
    return deque->front == deque->rear;
}

// 判满
bool isFull(struct Deque *deque) {
    return (deque->rear + 1) % MAX_SIZE == deque->front;
}

// 从队头插入元素
bool insertFront(struct Deque *deque, int value) {
    if (isFull(deque)) {
        printf("队列已满，无法从队头插入\n");
        return false;
    }
    deque->front = (deque->front - 1 + MAX_SIZE) % MAX_SIZE;
    deque->data[deque->front] = value;
    return true;
}

// 从队尾插入元素
bool insertRear(struct Deque *deque, int value) {
    if (isFull(deque)) {
        printf("队列已满，无法从队尾插入\n");
        return false;
    }
    deque->data[deque->rear] = value;
    deque->rear = (deque->rear + 1) % MAX_SIZE;
    return true;
}

// 从队头删除元素
bool deleteFront(struct Deque *deque, int *value) {
    if (isEmpty(deque)) {
        printf("队列为空，无法从队头删除\n");
        return false;
    }
    *value = deque->data[deque->front];
    deque->front = (deque->front + 1) % MAX_SIZE;
    return true;
}

// 从队尾删除元素
bool deleteRear(struct Deque *deque, int *value) {
    if (isEmpty(deque)) {
        printf("队列为空，无法从队尾删除\n");
        return false;
    }
    deque->rear = (deque->rear - 1 + MAX_SIZE) % MAX_SIZE;
    *value = deque->data[deque->rear];
    return true;
}

// 打印双端队列中的元素
void printDeque(struct Deque *deque) {
    if (isEmpty(deque)) {
        printf("队列为空\n");
        return;
    }
    int i = deque->front;
    while (i != deque->rear) {
        printf("%d ", deque->data[i]);
        i = (i + 1) % MAX_SIZE;
    }
    printf("\n");
}

int main() {
    struct Deque *deque = createDeque();

    insertRear(deque, 1);
    insertRear(deque, 2);
    insertFront(deque, 3);
    insertFront(deque, 4);
    printDeque(deque);  // 输出: 4 3 1 2

    int value;
    deleteFront(deque, &value);
    printf("从队头删除元素: %d\n", value);  // 输出: 4

    deleteRear(deque, &value);
    printf("从队尾删除元素: %d\n", value);  // 输出: 2

    printDeque(deque);  // 输出: 3 1

    // 测试队列满的情况
    insertRear(deque, 5);
    insertRear(deque, 6);
    if (!insertRear(deque, 7)) {
        printf("无法插入元素7，因为队列已满\n");
    }

    printDeque(deque);  // 输出: 3 1 5 6

    return 0;
}

这些基本就是队列的一些操作 

@haihi
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
数据结构——队列 求队列长度 C语言
03-16
输入若干个整数, 以0结束, 利用入队的操作生成一个循环队列, 求该队列的长度。
C++数据结构——队列
热门推荐
GeekZW的博客
06-26 17万+
C++数据结构——队列参考博客：http://www.cnblogs.com/QG-whz/p/5171123.htmlhttp://www.169it.com/article/2718050585107790752.html1、队列（Queue）与栈一样，是一种线性存储结构，它具有如下特点：（1）队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构；（...
数据结构 —— 队列
林深不见鹿 的博客
10-16 2794
队列 1.队列的介绍 队列是一种先进先出的数据结构，这和栈有所不同，但又更容易理解。类似于食堂排队打饭，车站排队买票。 后来的人排在队伍最后边，先来的人先打饭或者买票走。如图 队列总是从队尾插入元素,而从队首移除元素，满足先进先出的规则。因此需要一个队首指针front指向队首元素的前一个位置，而使用一个队尾指针rear来指向队尾元素。 ，需要一个队首指针front来指向队首元素的前一个位置，而使用一个队尾指针rear来指向队尾元素。和栈类似，当使用数组来实现队列时，队首指针front和队尾指针rear为i
数据结构——队列和链表
荔枝当大佬的博客
02-27 1145
还有一个多月就要打蓝桥杯了，荔枝最近开始学习一些基本的数据结构和算法，接下来在数据结构这个专栏里可以看到荔枝学习的脚步哦哈哈哈哈。在这篇文章中，荔枝主要做了一下队列和链表的基础知识笔记。
数据结构——队列（FIFO）
Xyzone007的博客
08-02 5269
数据结构——队列（FIFO） 队列的分类：顺序队列、链队列 顺序队列 在 FIFO 数据结构中，将首先处理添加到队列中的第一个元素。队列是典型的 FIFO 数据结构。插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。 删除（delete）操作也被称为出队（dequeue)。 你只能移除第一个元素。 顺序队列： 队列的头——front 队列的尾——back 1）空队列： 队列中必然会有front和back，当队列为空队列时，则有和front=back； 与栈的区别：栈先入后
数据结构——队列的应用.doc
07-11
数据结构中的队列是一种线性数据结构，它遵循“先进先出”（FIFO, First In First Out）的原则。在本实验中，我们主要探讨了队列的应用，特别是在实现杨辉三角输出上的应用。 首先，我们需要理解循环队列。循环队列...
算法和数据结构——队列.pdf
08-07
队列是一种基础且重要的数据结构，它遵循“先进先出”（FIFO，First In First Out）的原则。在队列中，元素的插入（入队）发生在队尾，而删除（出队）则发生在队头。这个概念可以类比于现实生活中人们排队购物的情景...
【数据结构】—— 树和二叉树
mist的博客
08-26 1290
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构：用栈实现队列（232）LeetCode
2303_81073778的博客
08-26 660
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1507
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 885
浅谈【数据结构】树与二叉树之哈夫曼树
【数据结构】-----哈希
最新发布
m0_73470633的博客
08-29 581
一文看懂哈希结构！
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1129
KMP算法：理解next[]表
集合及数据结构第十二节（下）————哈希表、字符串常量池和练习题
2301_79418684的博客
08-26 826
哈希表、字符串常量池和练习题 1. 哈希表的概念 2. 冲突-概念 3. 冲突-避免 4. 冲突-解决 5. 冲突严重时的解决办法 6. 冲突严重时的解决办法的实现 7. 性能分析 8. 和 java 类集的关系 9. Hashmap的使用案例 10. 模拟实现HashMap（k-v模型） 11. 创建对象的思考 12. 字符串常量池(StringTable) 13. 再谈String对象创建 14. 练习
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 1054
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
浅谈【数据结构】树与二叉树之平衡二叉树
weixin_67526434的博客
08-26 302
浅谈【数据结构】树与二叉树之平衡二叉树
【Java & 数据结构】二叉搜索树 & TreeMap 和 TreeSet 介绍
qq_42150700的博客
08-29 454
很明显, 对于二叉搜索树来说, 如果它树的分布是对半分布的, 如下图左侧的二叉树所示. 那么此时在查找过程中每经过一个节点都会排除一半的元素, 类似于二分查找, 因此理想情况下查找的时间复杂度是 O(logN). 但是如果是最坏情况, 二叉搜索树会是一棵单叉树, 如右图所示, 那么此时每一次都只能排除一个节点, 此时查找的时间复杂度就是 O(N) 了。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值