c语言数据结构线性结构队列的初始化

以下是C语言数据结构线性结构队列的初始化方法：

1. 链式队列的初始化

void InitQueue(Queue *Q){
    Q->front = Q->rear = (Node*)malloc(sizeof(Node));
    if(!Q->front) exit(0); //内存分配失败
    Q->front->Next = NULL;
    Q->length = 0;
}

2. 顺序队列的初始化

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

相关问题

c语言数据结构中的链队列代码完整版

在C语言中，链队列是一种线性数据结构，它通过节点（data和指向下一个节点的指针）链接起来实现先进先出（FIFO）的操作。下面是一个简单的单向链表实现的循环链队列的代码：

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

// 链队列节点结构体
typedef struct Node {
    int data; // 数据域
    struct Node* next; // 指向下一个节点的指针
} QueueNode;

// 初始化链队列为空
QueueNode* createQueue() {
    return (QueueNode*)malloc(sizeof(QueueNode));
}

// 在队尾插入元素
void enqueue(QueueNode** front, int value) {
    QueueNode* newNode = createQueue();
    if (*front == NULL) {
        *front = newNode;
        newNode->next = *front;
    } else {
        newNode->next = *front;
        (*front)->next = newNode;
    }
}

// 从队首删除并返回元素
int dequeue(QueueNode** front) {
    if (*front == NULL) {
        printf("Error: Queue is empty.\n");
        return -1;
    }

    int removedValue = (*front)->data;
    QueueNode* temp = *front;
    *front = (*front)->next;

    free(temp);
    return removedValue;
}

// 打印链队列
void printQueue(QueueNode* front) {
    QueueNode* current = front;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

int main() {
    QueueNode* front = createQueue();

    // 插入元素
    enqueue(&front, 10);
    enqueue(&front, 20);
    enqueue(&front, 30);

    // 打印队列
    printQueue(front); // 输出：30 20 10

    // 删除元素并打印
    printf("Removed element: %d\n", dequeue(&front)); // 输出：30
    printQueue(front); // 输出：20 10

    return 0;
}

写一个数据结构链队列的链式表示与实现c语言

链队列是一种线性数据结构，它的特点是先进先出（First In First Out，FIFO）。在链式表示中，每个节点包含两个部分：一个是存储元素的数据域，另一个是指向下一个节点的指针。以下是C语言中链队列的一种简单实现：

// 定义链队列节点结构体
typedef struct Node {
    int data;            // 存储数据域
    struct Node* next;   // 指向下一个节点的指针
} QueueNode;

// 链队列的头结点定义
typedef struct Queue {
    QueueNode* front;   // 队首指针
    QueueNode* rear;     // 队尾指针
    int size;           // 队列大小
} Queue;

// 初始化一个新的空队列
Queue* createQueue() {
    Queue* queue = (Queue*)malloc(sizeof(Queue));
    queue->front = NULL;
    queue->rear = NULL;
    queue->size = 0;
    return queue;
}

// 插入元素到队尾
void enqueue(Queue* queue, int value) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->data = value;
    newNode->next = NULL;

    if (queue->rear == NULL) {
        queue->front = newNode;
        queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
    queue->size++;
}

// 删除并返回队首元素
int dequeue(Queue* queue) {
    if (queue->front == NULL) {
        printf("Queue is empty.\n");
        return -1;
    }

    int value = queue->front->data;
    QueueNode* temp = queue->front;
    queue->front = queue->front->next;

    if (queue->front == NULL) {
        queue->rear = NULL;
    }

    free(temp);
    queue->size--;
    return value;
}

// 查看队列是否为空
int isEmpty(Queue* queue) {
    return queue->front == NULL;
}

// 获取队列长度
int getSize(Queue* queue) {
    return queue->size;
}

// 关闭链队列释放内存
void destroyQueue(Queue* queue) {
    QueueNode* current = queue->front;
    while (current != NULL) {
        QueueNode* temp = current;
        current = current->next;
        free(temp);
    }
    free(queue);
}