队列的两种实现方式

队列：

• 是这一种先进先出的数据结构。

• 队列（Queue） 是只允许在一端进行插入，在另一端删除的线性表

• 两种实现方式：

  • 顺序表实现
  • 链表实现

顺序表实现：

#include "stdio.h"
#include "stdlib.h"
#include "stdbool.h"

#define MAX_SIZE 10
typedef struct Sq_queue
{
    int data[MAX_SIZE];
    int rear; //队头指针
    int font; // 队尾指针
}Sq_queue;

// 初始化队列
bool InitQueue(Sq_queue *s){
    s->rear = s->font = 0;
    return true;
}   

// 入队列
bool EnQueue(Sq_queue *s,int e){
    if((s->rear+1)%MAX_SIZE == s->font){
        return false;
    }
    s->data[s->rear] = e;
    s->rear = (s->rear+1)%MAX_SIZE;
    return true;

}

// 出队列
bool DeQueue(Sq_queue *s,int *e){
    if(s->rear == s->font){
        return false;
    }
    *e = s->data[s->font];
    s->font = (s->font+1)%MAX_SIZE;
}

// 获取队头元素
bool GetHead(Sq_queue *s,int *e){
    if(s->rear == s->font){
        return false;
    }

    *e = s->data[s->font];
    return true;
}

bool Printqueue(Sq_queue s){
    while (s.font != s.rear)
    {
        printf("%d->",s.data[s.font]);
        s.font++;
    }
    printf("NULL\n");
}

// 主函数
int main(){
    Sq_queue s;
    InitQueue(&s);
    for (int i = 0; i < MAX_SIZE+4; i++)
    {
        if(!EnQueue(&s,i)){
            printf("元素%d插入失败\n",i);
        }
    }
    Printqueue(s);
    int e = 0;
    DeQueue(&s,&e);
    DeQueue(&s,&e);
    Printqueue(s);
    
    return 0;
}

顺序表实现运行结果：

链表实现：

/*
    链栈实现原理：链栈主要通过两个指针一个头指针一个尾指针，
                链栈无需像顺序栈那样来担心元素会超过存储大小的问题。  
*/

#include "stdio.h"
#include "stdlib.h"
#include "stdbool.h"

typedef struct QNode
{
    int data;
    struct QNode *next;     
}QNode;

typedef struct link_queue
{
    QNode *rear,*font;
}link_queue;
// 我们采取用重新定义一个结构体,里面放入两个QNode类型的指针来

// 初始化链栈
void InitQueue(link_queue *Q){
    Q->font = Q->rear = (QNode *)malloc(sizeof(QNode));
    Q->font->next = NULL;
}

// 入队
bool EnQueue(link_queue *Q,int e){
    QNode* node = (QNode *)malloc(sizeof(QNode));
    node->data = e;
    node->next = Q->rear->next;
    Q->rear->next = node;
    Q->rear = node;
    return true; 
}

// 出队列
bool DeQueue(link_queue *Q,int *e){
    if(Q->font == Q->rear){
        return false;
    }
    QNode* node = Q->font->next;
    *e = node->data;
     Q->font->next = node->next;
    if(node->next == NULL){
        Q->rear = Q->font;
    }
    free(node);
    return true;
}

// 获取队首元素
bool GetHead(link_queue *Q,int *e){
    if(Q->font == Q->rear){
        return false;
    }

    *e = Q->font->next->data;
    return true; 
}

bool Printqueue(link_queue s){
    s.font = s.font->next;
    while (s.font != s.rear)
    {   
        printf("%d->",s.font->data);
        s.font = s.font->next;
    }
    printf("%d->",s.font->data);
    printf("NULL\n");
}

// 
// 主函数
int main(){
    link_queue Q;
    InitQueue(&Q);

    int x;
    EnQueue(&Q,1);
    EnQueue(&Q,2);
    Printqueue(Q);
    GetHead(&Q,&x);
    printf("%d\n",x);
    EnQueue(&Q,3);
    EnQueue(&Q,4);
    Printqueue(Q);
    DeQueue(&Q,&x);
    Printqueue(Q);
}

链表实现运行结果图：