写队列的链队列的初始化,入队,出队,取队头,队列长度;循环队列的初始化,入队,出队,取队头,队列长度;

链队列的初始化、入队、出队、取队头、队列长度的代码如下：

// 链队列结构体
struct QueueNode {
    int data;
    QueueNode *next;
};

struct LinkQueue {
    QueueNode *front;  // 队头指针
    QueueNode *rear;   // 队尾指针
};

// 初始化队列
void InitQueue(LinkQueue &Q) {
    Q.front = Q.rear = new QueueNode;  // 初始化队头队尾指针
    Q.front->next = nullptr;           // 队列为空
}

// 入队操作
void EnQueue(LinkQueue &Q, int x) {
    QueueNode *p = new QueueNode;
    p->data = x;
    p->next = nullptr;
    Q.rear->next = p;  // 新节点插入队尾
    Q.rear = p;        // 队尾指针指向新节点
}

// 出队操作
bool DeQueue(LinkQueue &Q, int &x) {
    if (Q.front == Q.rear) return false;  // 队列为空
    QueueNode *p = Q.front->next;         // 指向队头节点
    x = p->data;                          // 取出队头元素
    Q.front->next = p->next;              // 队头指针指向下一个节点
    if (Q.rear == p) Q.rear = Q.front;    // 队列中只有一个元素时，删除后队尾指针也要指向头节点
    delete p;                             // 释放节点内存
    return true;
}

// 取队头元素
bool GetHead(LinkQueue &Q, int &x) {
    if (Q.front == Q.rear) return false;  // 队列为空
    x = Q.front->next->data;              // 获取队头元素
    return true;
}

// 队列长度
int QueueLength(LinkQueue &Q) {
    int len = 0;
    QueueNode *p = Q.front;
    while (p != Q.rear) {
        len++;
        p = p->next;
    }
    return len;
}

循环队列的初始化、入队、出队、取队头、队列长度的代码如下：

const int MAXSIZE = 50;  // 循环队列长度

struct SqQueue {
    int data[MAXSIZE];
    int front, rear;  // 队头、队尾指针
};

// 初始化队列
void InitQueue(SqQueue &Q) {
    Q.front = Q.rear = 0;
}

// 入队操作
bool EnQueue(SqQueue &Q, int x) {
    if ((Q.rear + 1) % MAXSIZE == Q.front) return false;  // 队列已满
    Q.data[Q.rear] = x;                                   // 将新元素插入队尾
    Q.rear = (Q.rear + 1) % MAXSIZE;                      // 队尾指针向后移动
    return true;
}

// 出队操作
bool DeQueue(SqQueue &Q, int &x) {
    if (Q.front == Q.rear) return false;  // 队列为空
    x = Q.data[Q.front];                  // 取出队头元素
    Q.front = (Q.front + 1) % MAXSIZE;    // 队头指针向后移动
    return true;
}

// 取队头元素
bool GetHead(SqQueue &Q, int &x) {
    if (Q.front == Q.rear) return false;  // 队列为空
    x = Q.data[Q.front];                  // 获取队头元素
    return true;
}

// 队列长度
int QueueLength(SqQueue &Q) {
    return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}