数据结构与算法-队列

参考学习：B站-逊哥带你学编程

队列的定义与实现

队列的顺序结构实现

#define MAXSIZE 100
typedef int ElemType;

typedef struct
{
    ElemType data[MAXSIZE];
    int front;
    int rear;
}Queue;

图示：

队列的顺序结构-初始化

void initQueue(Queue *Q)
{
    Q->front = 0;
    Q->rear = 0;
}

队列的顺序结构-判断队列是否为空

int isEmpty(Queue *Q)
{
    if(Q->front == Q->rear)
    {
        printf("Queue is empty\n");
        return 1;
    }
    return 0;
}

图示：

队列的顺序结构-出队

ElemType dequeue(Queue *Q)
{
    if(Q->front == Q->rear) //队列为空
    {
        printf("Queue is empty\n"); //队列为空
        return 0;
    }
    ElemType e = Q->data[Q->front]; //取出队头元素
    Q->front++; //队头指针后移
    return e; //返回队头元素
}

图示：

队列的顺序结构-入队

int queueFull(Queue *Q)
{
    if(Q->front > 0)
    {
        int step = Q->front;
        for(int i=Q ->front; i<=Q->rear; i++)
        {
            Q->data[i-step] = Q->data[i];
        }
        Q->front = 0;
        Q->rear = Q->rear - step;
        return 1;
    }
    else
    {
        printf("Queue is full\n"); //队列已满
        return 0;
    }
}

int enqueue(Queue *Q, ElemType e)
{
    if(Q->rear >= MAXSIZE) 
    {
        if(!queueFull(Q)) //队列已满
        {
            printf("Queue is full\n"); //队列已满
            return 0;
        }
        
    }
    Q->data[Q->rear] = e; //入队
    Q->rear++; //队尾指针后移
    return 1;
}

队列的顺序结构-获取队头数据

int getFront(Queue *Q, ElemType *e)
{
    if(Q->front == Q->rear) //队列为空
    {
        printf("Queue is empty\n"); //队列为空
        return 0;
    }
    *e = Q->data[Q->front]; //取出队头元素
    return 1;
}

队列的顺序结构-动态内存分配

typedef struct
{
    ElemType *data;
    int front;
    int rear;
}Queue;

Queue *initQueue()
{
    Queue *Q = (Queue *)malloc(sizeof(Queue));
    Q->data = (ElemType *)malloc(sizeof(ElemType)*MAXSIZE);
    Q->front = 0;
    Q->rear = 0;
    return Q;
}

队列的顺序结构-循环队列-入队

int equeue(Queue *Q, ElemType e)
{
    if((Q->rear + 1 ) % MAXSIZE == Q->front) //队列已满
    {
        printf("Queue is full\n");
        return 0;
    }
    Q->data[Q->rear] = e; //入队
    Q->rear = (Q->rear + 1) % MAXSIZE; //队尾指针后移
    return 1;
}

队列的顺序结构-循环队列-出队

int dequeue(Queue *Q, ElemType *e)
{
    if(Q->front == Q->rear) //队列为空
    {
        printf("Queue is empty\n"); //队列为空
        return 0;
    }
    *e = Q->data[Q->front]; //取出队头元素
    Q->front = (Q->front + 1) % MAXSIZE; //队头指针后移
    return 1;
}

队列的链式结构

队列的链式结构-初始化

typedef struct QueueNode
{
    ElemType data;
    struct QueueNode *next;
}QueueNode;

typedef struct
{
    QueueNode *front;
    QueueNode *rear;
}Queue;

Queue *initQueue()
{
    Queue *Q = (Queue *)malloc(sizeof(Queue));
    QueueNode *node = (QueueNode *)malloc(sizeof(QueueNode));
    node->data = 0;
    node->next = NULL;
    Q->front = node;
    Q->rear = node;
    return Q;
}

队列的链式结构-判断队列是否为空

int isEmpty(Queue *Q)
{
    if(Q->front == Q->rear)
    {
        printf("Queue is empty\n");
        return 1;
    }
    return 0;
}

队列的链式结构-入队

可以使用链表的头插法或尾插法。

使用尾插法：

void equeue(Queue *Q, ElemType e)
{
    QueueNode *node = (QueueNode *)malloc(sizeof(QueueNode)); //分配内存
    node->data = e; //赋值
    node->next = NULL; //指向空
    Q->rear->next = node; //队尾节点指向新节点
    Q->rear = node; //新节点为队尾节点
}

队列的链式结构-出队

int dequeue(Queue *q, ElemType *e)
{
    QueueNode *node = q->front->next; //指向队头节点
    *e = node->data; //保存队头节点的值
    q->front->next = node->next; //队头节点指向下一个节点
    if(q->rear == node) //若队尾节点为队头节点
    {
        q->rear = q->front; //队尾节点指向队头节点
    }
    free(node); //释放内存
    return 1;
}

队列的链式结构-获取队头元素

ElemType getFront(Queue *Q)
{
    if(Q->front == Q->rear)
    {
        printf("Queue is empty\n");
        return 0;
    }
    return Q->front->next->data; //返回队头元素
}

双端队列