队列

最新推荐文章于 2024-07-10 15:18:52 发布
最新推荐文章于 2024-07-10 15:18:52 发布
阅读量373 收藏
点赞数
分类专栏： 数据结构：C描述（data structures in C） 文章标签： 队列 queue enqueue dequeue 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaohao2004/article/details/54982585
版权

前言
　　本文在完成过程中，得到许多朋友的帮助，在此谢谢诸位。本人欢乐无限，技术有限，如有任何问题，欢迎各位不吝赐教。

1 队列是什么

　　队列是在表的一端进行插入，而在另一端进行删除的线性表。队列具有先进先出(FIFO, First In, First Out)特性。
　　在队列中，元素之间的位置关系主要有两个：

  • 队头（front）：进行删除的一端。
  • 队尾（rear）：进行插入的一端。

\
　　队列的基本操作是入队（enqueue）和出队（dequeue）。入队是在表的后端插入一个元素，程序中用enqueue(x, Q)实现。出队删除表的前端的元素，程序中用dequeue(Q)实现。
　　至此，大家应该对队列有了一个初步的认识。下面是一个队列模型，队列大小（指队列中元素的个数）为6。队头元素为a1，队尾元素为a6。
　　1

2 队列的实现

　　队列也是表，因此任何表的实现方法都可以用来实现队列。

2.1 队列的数组实现

　　对于使用数组实现的队列的数据结构，可以用下面的图来直观的说明：
２
　　从上面的图可以看到，队列的数据结构包括队列的结构（图中间的矩形）和队列的数组（图右边的矩形）两部分组成。
　　其中队列的结构包含5个成员：

  • capacity：int变量，队列的容量；
  • front：int变量，指示队头的位置；
  • rear：int变量，指示队尾的位置；
  • size： int变量，队列的大小；
  • array：指针，指向队列的数组。

\
　　特别指出的是front初始化为1，rear初始化为0。这使得队列不为空时，front指示队头而rear指示队尾。（注：有些程序员可能采用了不同的策略：rear指示队尾的下一位置）
　　队列的数组是一个动态数组，用来存储队列的数据元素。由于在程序运行时，队列的插入和删除随时都可能在进行，为了充分利用数组空间，这里数组的使用方法有点特别，就是当front或rear到达数组尾端的时候，如果再执行出队或入队操作，它们又绕回到数组的开头，这种数组叫做循环数组(circular array)。采用这种数组实现的队列也就成为循环队列。
　　下面是C实现的队列，首先是Queue.h的头文件：

typedef int ElementType;

#ifndef QUEUE_H
#define QUEUE_H

struct QueueRecord;
typedef struct QueueRecord *Queue;

int isEmpty( Queue Q );
int isFull( Queue Q );
Queue createQueue( int maxElements );
void disposeQueue( Queue Q );
void makeEmpty( Queue Q );
void enqueue( ElementType x, Queue Q );
ElementType front( Queue Q );
void dequeue( Queue Q );
ElementType frontAndDequeue( Queue Q );

#endif

　　下面是Fatal.h的头文件：

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

#define Error( Str )        FatalError( Str )
#define FatalError( Str )   fprintf( stderr, "%s\n", Str ), exit( 1 )

　　下面是Queue.c的源文件：

#include <stdlib.h>
#include "Queue.h"
#include "Fatal.h"

#define MinQueueSize ( 5 )

struct QueueRecord{
    int capacity;
    int front;
    int rear;
    int size;
    ElementType *array;
};

int isEmpty( Queue Q )
{
    return Q->size == 0;
}

int isFull( Queue Q )
{
    return Q->size == Q->capacity;
}

Queue createQueue( int maxElements )
{
    Queue Q;

    if( maxElements < MinQueueSize )
        Error( "Queue size is too small" );

    Q = malloc( sizeof( struct QueueRecord ) );
    if( Q == NULL )
        FatalError( "Out of space!!!" );

    Q->array = malloc( sizeof( ElementType ) * maxElements );
    if( Q->array == NULL )
        FatalError( "Out of space!!!" );
    Q->capacity = maxElements;
    makeEmpty( Q );

    return Q;
}

void makeEmpty( Queue Q )
{
    Q->size = 0;
    Q->front = 1;
    Q->rear = 0;
}

void disposeQueue( Queue Q )
{
    if( Q != NULL ) {
        free( Q->array );
        free( Q );
    }
}

void enqueue( ElementType x, Queue Q )
{
    if( isFull( Q ) )
        Error( "Full queue" );
    else {
        Q->size++;
        Q->rear = (Q->rear + 1) % Q->capacity;
        Q->array[ Q->rear ] = x;
    }
}

ElementType front( Queue Q )
{
    if( isEmpty( Q ) )
        Error( "Empty queue" );
    return Q->array[ Q->front ];
}

void dequeue( Queue Q )
{
    if( isEmpty( Q ) )
        Error( "Empty queue" );
    else {
        Q->size--;
        Q->front = (Q->front + 1) % Q->capacity;
    }
}

ElementType frontAndDequeue( Queue Q )
{
    ElementType x = 0;

    if( isEmpty( Q ) )
        Error( "Empty queue" );
    else {
        Q->size--;
        x = Q->array[ Q->front ];
        Q->front = (Q->front + 1) % Q->capacity;
    }
    return x;
}

　　测试程序main.c

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

int main(int argc, char *argv[]) 
{
    Queue Q;
    Q = createQueue( 5 );

    for(int i = 0; i < 10; i++ ){
        enqueue( i, Q );
        printf("%d ", isFull(Q));
    }

    printf("\n");
    while( !isEmpty( Q ) ) {
        printf( "%d\n", front( Q ) );
        dequeue( Q );
    }

    for(int i = 0; i < 20; i++ )
        enqueue( i, Q );

    while( !isEmpty( Q ) ) 
        printf( "%d\n", frontAndDequeue( Q ) );

    disposeQueue( Q );
    return 0;
}

2.2 队列的链表实现

　　队列也可以使用单链表实现。其数据结构包含了队列的大小size，指针front和rear。其中front指向头结点（注意不是队头，队头可以看做是头结点的后继），rear指向队尾。其初始状态可用如下模型表示：
３
　　下面是一个大小为n的队列，队头元素为A1，队尾元素为An。
４
　　我们通过在表的头结点后面插入来实现enqueue，在队尾后面插入来实现dequeue。
　　首先是Queue.h

typedef int ElementType;
#ifndef QUEUE_H
#define QUEUE_H

struct ListNode;
typedef struct ListNode *PtrToNode;
struct QueueRecord;
typedef struct QueueRecord *Queue;

int isEmpty(Queue Q);
Queue createQueue();
void disposeQueue(Queue Q);
void makeEmpty(Queue Q);
void enqueue();
ElementType front(Queue Q);
void dequeue(Queue Q);

#endif

　　Fatal.h

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

#define Error(str)      FatalError(str) 
#define FatalError(str) fprintf(stderr, "%s\n", str), exit(1)

　　Queue.c

#include <stdlib.h>
#include "Queue.h"
#include "Fatal.h"

struct ListNode{
    ElementType element;
    PtrToNode next;
};

struct QueueRecord{
    int size;
    PtrToNode front;
    PtrToNode rear;
};

int isEmpty(Queue Q)
{
    return Q->size == 0;
}

Queue createQueue()
{
    Queue Q = malloc(sizeof(struct QueueRecord));
    if(Q == NULL)
        FatalError("Out of space!!!");

    Q->size = 0;
    Q->front = Q->rear = malloc(sizeof(struct ListNode));
    if(Q->front == NULL)
        FatalError("Out of space!!!");
    Q->front->next = NULL;
    return Q;
}

void disposeQueue(Queue Q)
{
    makeEmpty(Q);
    free(Q);
}

void makeEmpty(Queue Q)
{
    while(!isEmpty(Q))
        dequeue(Q);
}

void enqueue(ElementType x, Queue Q)
{
    PtrToNode p = malloc(sizeof(struct ListNode));
    if(p == NULL)
        FatalError("Out of space!!!");

    p->element = x;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
    Q->size++;
}

ElementType front(Queue Q)
{
    return Q->front->next->element;
}

void dequeue(Queue Q)
{
    PtrToNode p = Q->front->next;
    Q->front->next = p->next;

    if(Q->front->next == NULL) //队列为空 
        Q->rear = Q->front;
    free(p);

    Q->size--;
}

　　测试程序main.c：

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

#include "Queue.h"

int main(int argc, char *argv[]) 
{
    Queue Q = createQueue( );

    for(int i = 0; i < 10; i++)
        enqueue( i, Q );

    while(!isEmpty( Q ) ) {
        printf( "%d\n", front( Q ) );
        dequeue( Q );
    }

    for(int i = 0; i < 10; i++)
        enqueue( i, Q );

    while(!isEmpty( Q ) ) {
        printf( "%d\n", front( Q ) );
        dequeue( Q );
    }

    disposeQueue( Q );
    return 0;
}
参考文献

[1] Mark Allen Weiss，数据结构与算法分析:C语言描述(原书第2版)
[2] Thomas H.Cormen，Charles E.Leiserson，Ronald L.Rivest，Clifford Stein，算法导论

与狼同行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c#中queue_C＃中的Queue.Enqueue（）方法示例
cumtb2002的博客
07-09 5837
c#中queue C＃Queue.Enqueue()方法 (C# Queue.Enqueue() method) Queue.Enqueue() method is used to add an object/element at the end of the Queue. Queue.Enqueue()方法用于在Queue的末尾添加一个对象/元素。 Syntax: 句法： voi...
数据结构——队列Queue
qq_58224022的博客
12-19 1069
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。rear在0下标插入元素的时候自己走在1下标，rear插入元素的时候始终站在空的格子上。2.根据队列先进先出，把存进队列的元素 出队列 到另一个队列，但是留出最后一个元素（图中的45）接收给他出队列。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（
C# 队列(Queue)
熊思雨的博客
05-26 1万+
表示对象的先进先出集合。队列和其他的数据结构一样，是一种存储容器，它遵循的原则，能够存储任意类型，但并不能获取到指定的位置，只能存入和取出，取出元素后，Queue 内部的元素自动删除，其实 队列 和 栈 使用方法和特点大致差不多，只是取出数据的顺序会有些不一样。
Java集合类学习--Queue, Deque
CodersCoder的博客
09-25 1062
概述 Queue 和 Deque 都是接口。其中 Queue 接口定义的是一个队列，它包含队列的基本操作：入队（enqueue）和出队（dequeue）。 Deque 接口继承自 Queue 接口，表示双端队列（Double-ended queue），同时具备「队列」和「栈」的性质。二者的继承关系如下： Queue Queue是一个接口，有如下方法： 代码不多，一共200多行，根据操作可以分为三类：入队、出队和遍历。 入队：add() 和 offer() 二者区别在于：当队列空间已满无法入队时，add
高效延时队列的设计与实现
09-02
【高效延时队列的设计与实现】 延时队列是一种特殊的消息队列，它具有延时功能，使得消息在生产者发布后不会立即被消费，而是会在预设的延时时间过后才被处理。这种机制在很多业务场景中非常有用，如订单处理、定时...
C#消息队列发送及接收
03-25
在IT行业中，消息队列（Message Queue，MQ）是一种常用于分布式系统中解耦组件、提高系统可扩展性和可靠性的技术。在C#编程中，我们可以利用Microsoft Message Queuing（MSMQ）库来实现消息队列的发送和接收。本文将...
Python队列的定义与使用方法示例
09-21
Python中的队列是一种重要的数据结构，它遵循先进先出（FIFO）的原则，即最早进入队列的元素最早被移出。在实际编程中，队列常用于任务调度、多线程间的通信以及缓存管理等领域。Python标准库提供了`queue`模块，...
Enqueue（队列等待）
逝鸿的博客
09-18 9991
参考自盖国强《深入解析oracle》 Enqueue 是一种保护共享资源的锁定机制。该锁定机制保护共享资源，以避免因并发操作而损坏数据，比如通过锁定保护一行记录，避免多个用户同时更新。Enqueue 采用排队机制，即 FIFO（先进先出）来控制资源的使用。 Oracle 在数据库内部用 Enqueue 等待来记录锁定，通过 Latch Free 等待事件来记录闩。Enqueue 等待常见的有
确保线程安全下使用Queue的Enqueue和Dequeue
weixin_30730151的博客
04-07 588
场景是这样，假设有一台设备会触发类型为Alarm的告警信号，并把信号添加到一个Queue结构中，每隔一段时间这个Queue会被遍历检查，其中的每个Alarm都会调用一个相应的处理方法。问题在于，检查机制是基于多线程的，有潜在的并发可能，当某个Alarm被添加的同时刚好又在遍历Queue，就会抛出异常说Queue发生改变。产生问题的代码如下： public class AlarmQueueMa...
oracle10g enq:TX - contention等待事件
iteye_13138的博客
06-25 252
oracle10g enq:TX - contention等待事件 10g中enqueue TX等待分为4类，分别是 1. enq:TX - row lock contention 2. enq:TX - index contention 3. enq:TX - ITL 4. enq:TX - contention 前三种的含义比较明显，第4种是表示其它类型的transactio...
使用数组实现队列和循环队列
qq_53933886的博客
10-03 695
使用数组实现队列和循环队列
c语言enqueue用法,C# Queue.Enqueue()用法及代码示例
weixin_39636850的博客
05-22 3752
此方法用于将对象添加到队列的末尾。这属于System.Collections命名空间。该值可以为null，并且如果Count小于内部数组的容量，则此方法是O(1)操作。如果需要重新分配内部数组以容纳新元素，则此方法将成为O(n)操作，其中n是Count。用法:public virtual void Enqueue (object obj);在这里，obj是添加到队列中的对象。例：// C# cod...
(C#)使用队列(Queue)解决简单的并发问题
热门推荐
程序人生
07-16 10万+
有一个场景：一个抢购的项目，假设有5件商品，谁先抢到谁可以买，但是如果此时此刻（这里的此时此刻假设是相同的时间），有100人去抢这个商品，如果使用平时的方法会出现什么情况呢？你懂的，这里所说是就是有关并发的问题。 平时我们去超市购物去结账的时候就是排队，这里我们先让抢购人排好队，按时间，谁先点击的抢购按钮谁就排在前面，这样就形成了一个队列，然后我们再对这个队列处理，这样就不会出现并发的问题了
数据结构之顺序表
最新发布
m0_73634434的博客
07-10 415
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值