二叉树的层序遍历c语言

二叉树的层序遍历可以使用队列来实现。具体步骤如下：

1. 定义一个队列，用于存储待访问的节点。
2. 将根节点入队。
3. 循环执行以下操作，直到队列为空：
- 弹出队首节点，并访问该节点。
- 如果该节点有左子节点，则将左子节点入队。
- 如果该节点有右子节点，则将右子节点入队。
4. 遍历结束。

下面是一个示例的C语言代码实现：

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

// 定义二叉树节点结构
typedef struct TreeNode {
    int val;             // 节点值
    struct TreeNode* left;   // 左子节点指针
    struct TreeNode* right;  // 右子节点指针
} TreeNode;

// 定义队列节点结构
typedef struct QueueNode {
    struct TreeNode* data;   // 队列节点数据
    struct QueueNode* next;  // 下一个队列节点指针
} QueueNode;

// 定义队列结构
typedef struct Queue {
    QueueNode* front;  // 队头指针
    QueueNode* rear;   // 队尾指针
} Queue;

// 初始化队列
void initQueue(Queue* queue) {
    queue->front = NULL;
    queue->rear = NULL;
}

// 入队操作
void enqueue(Queue* queue, TreeNode* data) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->data = data;
    newNode->next = NULL;
    
    if (queue->rear == NULL) {
        queue->front = newNode;
        queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

// 出队操作
TreeNode* dequeue(Queue* queue) {
    if (queue->front == NULL) {
        return NULL;
    }
    
    QueueNode* temp = queue->front;
    TreeNode* data = temp->data;
    
    queue->front = queue->front->next;
    if (queue->front == NULL) {
        queue->rear = NULL;
    }
    
    free(temp);
    return data;
}

// 层序遍历
void levelOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    
    Queue queue;
    initQueue(&queue);
    
    enqueue(&queue, root);
    
    while (queue.front != NULL) {
        TreeNode* node = dequeue(&queue);
        printf("%d ", node->val);
        
        if (node->left != NULL) {
            enqueue(&queue, node->left);
        }
        
        if (node->right != NULL) {
            enqueue(&queue, node->right);
        }
    }
}

int main() {
    // 构建二叉树
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = 1;
    
    TreeNode* node2 = (TreeNode*)malloc(sizeof(TreeNode));
    node2->val = 2;
    
    TreeNode* node3 = (TreeNode*)malloc(sizeof(TreeNode));
    node3->val = 3;
    
    TreeNode* node4 = (TreeNode*)malloc(sizeof(TreeNode));
    node4->val = 4;
    
    TreeNode* node5 = (TreeNode*)malloc(sizeof(TreeNode));
    node5->val = 5;
    
    root->left = node2;
    root->right = node3;
    node2->left = node4;
    node2->right = NULL;
    node3->left = NULL;
    node3->right = node5;
    node4->left = NULL;
    node4->right = NULL;
    node5->left = NULL;
    node5->right = NULL;
    
    // 层序遍历
    levelOrderTraversal(root);
    
    return 0;
}

上述代码中，首先定义了二叉树节点结构和队列节点结构，并初始化了队列。然后，使用队列实现层序遍历的核心部分。最后，在主函数中构建了一个示例二叉树，并调用层序遍历函数进行输出。