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

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

// 链队列的结点结构体
struct LinkNode {
    int data;
    LinkNode* next;
};

// 链队列的定义
struct LinkQueue {
    LinkNode* front;  // 队头指针
    LinkNode* rear;   // 队尾指针
};

// 链队列的初始化
void InitQueue(LinkQueue& q) {
    q.front = q.rear = new LinkNode;
    q.front->next = nullptr;
}

// 链队列的入队
void EnQueue(LinkQueue& q, int x) {
    LinkNode* s = new LinkNode;
    s->data = x;
    s->next = nullptr;
    q.rear->next = s;
    q.rear = s;
}

// 链队列的出队
bool DeQueue(LinkQueue& q, int& x) {
    if (q.front == q.rear)  // 队列为空
        return false;
    LinkNode* 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;
    LinkNode* p = q.front;
    while (p != q.rear) {
        len++;
        p = p->next;
    }
    return len;
}

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

// 循环队列的结构体
struct SqQueue {
    int* data;  // 存储队列元素的数组
    int front;  // 队头指针
    int rear;   // 队尾指针
    int size;   // 队列容量
};

// 循环队列的初始化
void InitQueue(SqQueue& q, int size) {
    q.data = new int[size];
    q.front = q.rear = 0;
    q.size = size;
}

// 循环队列的入队
bool EnQueue(SqQueue& q, int x) {
    if ((q.rear + 1) % q.size == q.front)  // 队列已满
        return false;
    q.data[q.rear] = x;
    q.rear = (q.rear + 1) % q.size;
    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) % q.size;
    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 + q.size) % q.size;
}

需要注意的是，在循环队列的实现中，用 `q.size` 表示队列的容量，而不是 `q.size - 1`，这是因为在队列满时，队尾指针 `q.rear` 指向的位置已经被占用了，因此队列的实际容量是 `q.size`，而不是 `q.size - 1`。