二叉树层序遍历原理与C语言实现详解

1. 二叉树层序遍历的核心概念

层序遍历（Level Order Traversal）是二叉树遍历中最直观的一种方式，它按照树的层级结构从上到下、从左到右依次访问每个节点。这种遍历方式在实际开发中有着广泛的应用场景，比如社交网络的好友推荐、文件系统的目录遍历等。

1.1 层序遍历与DFS的本质区别

深度优先遍历（DFS）和广度优先遍历（BFS）是树遍历的两大基本策略：

• DFS（前序/中序/后序）：沿着一条路径深入到底，再回溯探索其他分支。就像走迷宫时选择一条路走到头，遇到死胡同再返回。
• BFS（层序遍历）：按层次逐步展开，先访问离根节点最近的节点。类似水波纹扩散，一圈一圈向外扩展。

实际选择时：当需要处理"最近关系"（如最短路径）用BFS；当需要完全探索分支（如查找所有可能解）用DFS。

1.2 层序遍历的算法流程

层序遍历的标准实现需要借助队列数据结构：

1. 将根节点入队
2. 循环执行以下步骤直到队列为空：
   a. 出队一个节点并访问
   b. 将其左右子节点（如果存在）依次入队
3. 队列为空时遍历结束

这个过程的时空复杂度都是O(n)，因为每个节点恰好入队出队一次。

2. 基于C语言的完整实现

2.1 队列的基础实现

层序遍历依赖队列的FIFO特性，我们先实现一个通用队列：

c复制// queue.h
#pragma once
#include <stdbool.h>

typedef struct TreeNode* QDataType;  // 队列存储树节点指针

typedef struct QueueNode {
    QDataType data;
    struct QueueNode* next;
} QueueNode;

typedef struct Queue {
    QueueNode* front;
    QueueNode* rear;
    int size;
} Queue;

void QueueInit(Queue* q);
void QueueDestroy(Queue* q);
void QueuePush(Queue* q, QDataType data);
void QueuePop(Queue* q);
QDataType QueueFront(Queue* q);
bool QueueEmpty(Queue* q);
int QueueSize(Queue* q);

对应的实现文件：

c复制// queue.c
#include "queue.h"
#include <stdlib.h>
#include <assert.h>

void QueueInit(Queue* q) {
    assert(q);
    q->front = q->rear = NULL;
    q->size = 0;
}

void QueueDestroy(Queue* q) {
    assert(q);
    QueueNode* cur = q->front;
    while (cur) {
        QueueNode* next = cur->next;
        free(cur);
        cur = next;
    }
    q->front = q->rear = NULL;
    q->size = 0;
}

void QueuePush(Queue* q, QDataType data) {
    assert(q);
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    if (!newNode) {
        perror("malloc failed");
        exit(EXIT_FAILURE);
    }
    newNode->data = data;
    newNode->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
    q->size++;
}

void QueuePop(Queue* q) {
    assert(q);
    assert(!QueueEmpty(q));
    
    QueueNode* next = q->front->next;
    free(q->front);
    q->front = next;
    if (q->front == NULL) {
        q->rear = NULL;
    }
    q->size--;
}

QDataType QueueFront(Queue* q) {
    assert(q);
    assert(!QueueEmpty(q));
    return q->front->data;
}

bool QueueEmpty(Queue* q) {
    assert(q);
    return q->size == 0;
}

int QueueSize(Queue* q) {
    assert(q);
    return q->size;
}

2.2 二叉树结构定义

c复制// tree.h
#pragma once

typedef int TreeDataType;

typedef struct TreeNode {
    TreeDataType val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

TreeNode* CreateNode(TreeDataType x);
void LevelOrder(TreeNode* root);
bool IsCompleteTree(TreeNode* root);

2.3 层序遍历核心实现

c复制// tree.c
#include "tree.h"
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>

TreeNode* CreateNode(TreeDataType x) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    if (!newNode) {
        perror("malloc failed");
        exit(EXIT_FAILURE);
    }
    newNode->val = x;
    newNode->left = newNode->right = NULL;
    return newNode;
}

void LevelOrder(TreeNode* root) {
    if (!root) return;
    
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    
    while (!QueueEmpty(&q)) {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        printf("%d ", front->val);
        
        if (front->left) {
            QueuePush(&q, front->left);
        }
        if (front->right) {
            QueuePush(&q, front->right);
        }
    }
    QueueDestroy(&q);
}

2.4 判断完全二叉树

完全二叉树的定义是：除了最后一层，其他层节点都达到最大数，且最后一层节点都靠左排列。

c复制bool IsCompleteTree(TreeNode* root) {
    if (!root) return true;
    
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    
    bool reachNull = false;
    
    while (!QueueEmpty(&q)) {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        
        if (!front) {
            reachNull = true;
        } else {
            if (reachNull) {
                QueueDestroy(&q);
                return false;
            }
            QueuePush(&q, front->left);
            QueuePush(&q, front->right);
        }
    }
    QueueDestroy(&q);
    return true;
}

3. 层序遍历的进阶应用

3.1 按层打印二叉树

有时我们需要知道每个节点属于哪一层，可以通过记录队列大小来实现：

c复制void LevelOrderWithLevel(TreeNode* root) {
    if (!root) return;
    
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    int level = 1;
    
    while (!QueueEmpty(&q)) {
        int levelSize = QueueSize(&q);
        printf("Level %d: ", level++);
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode* front = QueueFront(&q);
            QueuePop(&q);
            printf("%d ", front->val);
            
            if (front->left) QueuePush(&q, front->left);
            if (front->right) QueuePush(&q, front->right);
        }
        printf("\n");
    }
    QueueDestroy(&q);
}

3.2 锯齿形层序遍历

即奇数层从左到右，偶数层从右到左打印：

c复制void ZigzagLevelOrder(TreeNode* root) {
    if (!root) return;
    
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    bool leftToRight = true;
    
    while (!QueueEmpty(&q)) {
        int levelSize = QueueSize(&q);
        int* levelNodes = (int*)malloc(levelSize * sizeof(int));
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode* front = QueueFront(&q);
            QueuePop(&q);
            
            int index = leftToRight ? i : levelSize - 1 - i;
            levelNodes[index] = front->val;
            
            if (front->left) QueuePush(&q, front->left);
            if (front->right) QueuePush(&q, front->right);
        }
        
        for (int i = 0; i < levelSize; i++) {
            printf("%d ", levelNodes[i]);
        }
        printf("\n");
        
        free(levelNodes);
        leftToRight = !leftToRight;
    }
    QueueDestroy(&q);
}

3.3 计算树的最大宽度

c复制int MaxWidth(TreeNode* root) {
    if (!root) return 0;
    
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    int maxWidth = 1;
    
    while (!QueueEmpty(&q)) {
        int levelSize = QueueSize(&q);
        maxWidth = levelSize > maxWidth ? levelSize : maxWidth;
        
        for (int i = 0; i < levelSize; i++) {
            TreeNode* front = QueueFront(&q);
            QueuePop(&q);
            
            if (front->left) QueuePush(&q, front->left);
            if (front->right) QueuePush(&q, front->right);
        }
    }
    QueueDestroy(&q);
    return maxWidth;
}

4. 常见问题与调试技巧

4.1 内存泄漏检查

在使用队列实现层序遍历时，最容易出现的问题是内存泄漏。确保：

1. 每次malloc后都有对应的free
2. 队列销毁时要释放所有节点
3. 树销毁时要递归释放所有节点

可以使用valgrind工具检查内存泄漏：

bash复制valgrind --leak-check=full ./your_program

4.2 队列操作常见错误

1. 空队列出队：在调用QueuePop前必须检查队列是否为空
2. 野指针问题：队列销毁后要将front和rear置为NULL
3. size同步问题：所有修改队列结构的操作都要同步更新size

4.3 二叉树构建技巧

为了方便测试，可以编写一个辅助函数构建二叉树：

c复制TreeNode* BuildTestTree() {
    TreeNode* root = CreateNode(1);
    root->left = CreateNode(2);
    root->right = CreateNode(3);
    root->left->left = CreateNode(4);
    root->left->right = CreateNode(5);
    root->right->left = CreateNode(6);
    return root;
}

4.4 层序遍历的变种问题

1. 右视图二叉树：每层只打印最右边的节点
2. 左视图二叉树：每层只打印最左边的节点
3. 边界遍历：打印树的左边界、叶子节点、右边界
4. 垂直遍历：按列打印节点

这些问题的解法都基于层序遍历，通过调整访问顺序和记录额外信息来实现。

5. 性能优化与扩展思考

5.1 递归实现层序遍历

虽然队列实现是标准解法，但也可以使用递归：

c复制void LevelOrderRecursive(TreeNode* root, int level) {
    if (!root) return;
    if (level == 1) {
        printf("%d ", root->val);
    } else {
        LevelOrderRecursive(root->left, level-1);
        LevelOrderRecursive(root->right, level-1);
    }
}

void LevelOrderWrapper(TreeNode* root) {
    int height = TreeHeight(root);
    for (int i = 1; i <= height; i++) {
        LevelOrderRecursive(root, i);
    }
}

不过递归实现的时间复杂度是O(n²)，不如队列实现的O(n)高效。

5.2 使用双队列优化

在某些场景下，使用两个队列可以避免频繁计算队列大小：

c复制void LevelOrderTwoQueues(TreeNode* root) {
    if (!root) return;
    
    Queue current, next;
    QueueInit(&current);
    QueueInit(&next);
    QueuePush(&current, root);
    
    while (!QueueEmpty(&current)) {
        TreeNode* front = QueueFront(&current);
        QueuePop(&current);
        printf("%d ", front->val);
        
        if (front->left) QueuePush(&next, front->left);
        if (front->right) QueuePush(&next, front->right);
        
        if (QueueEmpty(&current)) {
            printf("\n");
            Queue temp = current;
            current = next;
            next = temp;
        }
    }
    QueueDestroy(&current);
    QueueDestroy(&next);
}

5.3 层序遍历在算法题中的应用

1. 二叉树的最小深度：第一个遇到的叶子节点所在的层数
2. 填充每个节点的下一个右侧指针：完美二叉树的连接问题
3. 二叉树的序列化与反序列化：使用层序遍历可以高效实现
4. 找树左下角的值：最后一层的第一个节点

这些问题的解法核心都是层序遍历的变种，理解基础实现后可以灵活应用。