数据结构初阶：二叉树的链式存储结构详解

该结构对应的二叉树形状如下（示意图）： [图：二叉树结构示意图]

三、链式二叉树的基本操作

3.1 前序遍历

前序遍历遵循'根->左->右'的顺序。使用递归实现最为直观。

void PreOrder(BTNode* root) {
    if (root == NULL) {
        printf("NULL ");
        return;
    }
    printf("%c ", root->data);
    PreOrder(root->leftChild);
    PreOrder(root->rightChild);
}

原理解析： 递归终止条件是节点为空。对于叶子节点，左右孩子均为 NULL，函数直接返回。整体流程是访问当前节点，然后深入左子树，最后深入右子树。

3.2 中序遍历

中序遍历遵循'左->根->右'的顺序。

void InOrder(BTNode* root) {
    if (root == NULL) {
        printf("NULL ");
        return;
    }
    InOrder(root->leftChild);
    printf("%c ", root->data);
    InOrder(root->rightChild);
}

3.3 后序遍历

后序遍历遵循'左->右->根'的顺序。

void LastOrder(BTNode* root) {
    if (root == NULL) {
        printf("NULL ");
        return;
    }
    LastOrder(root->leftChild);
    LastOrder(root->rightChild);
    printf("%c ", root->data);
}

3.4 计算二叉树的总结点个数

统计节点总数可以通过递归累加左右子树的节点数。

int BinaryTreeSize_of_Node(BTNode* root) {
    if (root == NULL) {
        return 0;
    }
    return 1 + BinaryTreeSize_of_Node(root->leftChild) + BinaryTreeSize_of_Node(root->rightChild);
}

3.5 计算二叉树的叶子结点个数

叶子节点定义为左右孩子均为空的节点。

int BinaryTreesize_of_Leaf(BTNode* root) {
    if (root == NULL) return 0;
    if (root->leftChild == NULL && root->rightChild == NULL) return 1;
    return BinaryTreesize_of_Leaf(root->leftChild) + BinaryTreesize_of_Leaf(root->rightChild);
}

3.6 计算第 k 层节点个数

通过递归减少 k 值，当 k=1 时说明到达目标层。

int BinaryTreeSize_of_K(BTNode* root, int k) {
    if (root == NULL) return 0;
    if (k == 1) return 1;
    return BinaryTreeSize_of_K(root->leftChild, k - 1) + BinaryTreeSize_of_K(root->rightChild, k - 1);
}

3.7 计算二叉树的深度

深度即树的高度，取左右子树深度的最大值加 1。

int BinaryTreeSize_of_Depth(BTNode* root) {
    if (root == NULL) {
        return 0;
    }
    int leftDepth = BinaryTreeSize_of_Depth(root->leftChild);
    int rightDepth = BinaryTreeSize_of_Depth(root->rightChild);
    return 1 + (leftDepth > rightDepth ? leftDepth : rightDepth);
}

3.8 查找元素

遍历整棵树查找指定值的节点。

void BinaryTreeSearch_of_val(BTNode* root, Elemtype val) {
    if (root == NULL) return;
    if (root->data == val) {
        printf("找到了!\n");
        return;
    }
    BinaryTreeSearch_of_val(root->leftChild, val);
    BinaryTreeSearch_of_val(root->rightChild, val);
}

3.9 层序遍历

层序遍历需要使用队列辅助，按层级从左到右访问。

void LevelOrder(BTNode* root) {
    Queue q;
    Queue* pQueue = &q;
    InitQueue(pQueue);

    Push_Queue(pQueue, root);
    while (!isEmpty(pQueue)) {
        BTNode* top = GetElemFront(pQueue);
        printf("%c ", top->data);
        Pop_Queue(pQueue);

        if (top->leftChild) {
            Push_Queue(pQueue, top->leftChild);
        }
        if (top->rightChild) {
            Push_Queue(pQueue, top->rightChild);
        }
    }
    DestroyQueue(pQueue);
}

3.10 判断是否为完全二叉树

利用层序遍历，遇到空节点后，后续所有节点必须都为空。

bool IsBinaryTree_of_Complete(BTNode* root) {
    Queue q;
    Queue* pQueue = &q;
    InitQueue(pQueue);

    Push_Queue(pQueue, root);
    while (!isEmpty(pQueue)) {
        QElemtype top = GetElemFront(pQueue);
        Pop_Queue(pQueue);
        if (top == NULL) {
            break;
        }
        Push_Queue(pQueue, top->leftChild);
        Push_Queue(pQueue, top->rightChild);
    }

    while (!isEmpty(pQueue)) {
        BTNode* top = GetElemFront(pQueue);
        Pop_Queue(pQueue);
        if (top != NULL) {
            DestroyQueue(pQueue);
            return false;
        }
    }
    DestroyQueue(pQueue);
    return true;
}

3.11 外部代码的引入

层序遍历依赖队列结构。在实际工程中，应将队列的实现封装为头文件（如 Queue.h），并在当前文件中包含该头文件。注意类型定义的一致性，例如队列元素类型应适配为 struct BinaryTree*。

四、综合代码

以下是整合后的完整代码示例，包含二叉树定义及核心操作。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include"Queue.h"

typedef char Elemtype;

typedef struct BinaryTree {
    Elemtype data;
    struct BinaryTree* leftChild;
    struct BinaryTree* rightChild;
} BTNode;

BTNode* BuyNode(Elemtype data) {
    BTNode* newNode = (BTNode*)malloc(sizeof(BTNode));
    if (newNode == NULL) {
        perror("create new node fail!\n");
        return NULL;
    }
    newNode->data = data;
    newNode->leftChild = newNode->rightChild = NULL;
    return newNode;
}

BTNode* createNewBT() {
    BTNode* NodeA = BuyNode('A');
    BTNode* NodeB = BuyNode('B');
    BTNode* NodeC = BuyNode('C');
    BTNode* NodeD = BuyNode('D');
    BTNode* NodeE = BuyNode('E');
    BTNode* NodeF = BuyNode('F');
    BTNode* NodeG = BuyNode('G');
    BTNode* NodeH = BuyNode('H');
    BTNode* NodeI = BuyNode('I');
    BTNode* NodeO = BuyNode('O');

    NodeA->leftChild = NodeB;
    NodeA->rightChild = NodeC;
    NodeB->leftChild = NodeD;
    NodeB->rightChild = NodeE;
    NodeD->leftChild = NodeH;
    NodeC->leftChild = NodeF;
    NodeF->leftChild = NodeI;
    NodeH->leftChild = NodeO;

    return NodeA;
}

void PreOrder(BTNode* root) {
    if (root == NULL) {
        printf("NULL ");
        return;
    }
    printf("%c ", root->data);
    PreOrder(root->leftChild);
    PreOrder(root->rightChild);
}

void InOrder(BTNode* root) {
    if (root == NULL) {
        printf("NULL ");
        return;
    }
    InOrder(root->leftChild);
    printf("%c ", root->data);
    InOrder(root->rightChild);
}

void LastOrder(BTNode* root) {
    if (root == NULL) {
        printf("NULL ");
        return;
    }
    LastOrder(root->leftChild);
    LastOrder(root->rightChild);
    printf("%c ", root->data);
}

int BinaryTreeSize_of_Node(BTNode* root) {
    if (root == NULL) {
        return 0;
    }
    return 1 + BinaryTreeSize_of_Node(root->leftChild) + BinaryTreeSize_of_Node(root->rightChild);
}

int BinaryTreesize_of_Leaf(BTNode* root) {
    if (root == NULL) {
        return 0;
    }
    if (root->leftChild == NULL && root->rightChild == NULL) {
        return 1;
    }
    return BinaryTreesize_of_Leaf(root->rightChild) + BinaryTreesize_of_Leaf(root->leftChild);
}

int BinaryTreeSize_of_K(BTNode* root, int k) {
    if (root == NULL) {
        return 0;
    }
    if (k == 1) {
        return 1;
    } else {
        return BinaryTreeSize_of_K(root->rightChild, k - 1) + BinaryTreeSize_of_K(root->leftChild, k - 1);
    }
}

int BinaryTreeSize_of_Depth(BTNode* root) {
    if (root == NULL) {
        return 0;
    }
    int leftDepth = BinaryTreeSize_of_Depth(root->leftChild);
    int rightDepth = BinaryTreeSize_of_Depth(root->rightChild);
    return 1 + (leftDepth > rightDepth ? leftDepth : rightDepth);
}

void BinaryTreeSearch_of_val(BTNode* root, Elemtype val) {
    if (root == NULL) {
        return;
    }
    if (root->data == val) {
        printf("找到了!\n");
        return;
    }
    BinaryTreeSearch_of_val(root->leftChild, val);
    BinaryTreeSearch_of_val(root->rightChild, val);
}

void LevelOrder(BTNode* root) {
    Queue q;
    Queue* pQueue = &q;
    InitQueue(pQueue);

    Push_Queue(pQueue, root);
    while (!isEmpty(pQueue)) {
        BTNode* top = GetElemFront(pQueue);
        printf("%c ", top->data);
        Pop_Queue(pQueue);
        if (top->leftChild) {
            Push_Queue(pQueue, top->leftChild);
        }
        if (top->rightChild) {
            Push_Queue(pQueue, top->rightChild);
        }
    }
    DestroyQueue(pQueue);
}

bool IsBinaryTree_of_Complete(BTNode* root) {
    Queue q;
    Queue* pQueue = &q;
    InitQueue(pQueue);

    Push_Queue(pQueue, root);
    while (!isEmpty(pQueue)) {
        QElemtype top = GetElemFront(pQueue);
        Pop_Queue(pQueue);
        if (top == NULL) {
            break;
        }
        Push_Queue(pQueue, top->leftChild);
        Push_Queue(pQueue, top->rightChild);
    }

    while (!isEmpty(pQueue)) {
        BTNode* top = GetElemFront(pQueue);
        Pop_Queue(pQueue);
        if (top != NULL) {
            DestroyQueue(pQueue);
            return false;
        }
    }
    DestroyQueue(pQueue);
    return true;
}

int main() {
    BTNode* NodeA = createNewBT();
    printf("前序遍历:");
    PreOrder(NodeA);
    printf("\n");

    printf("中序遍历:");
    InOrder(NodeA);
    printf("\n");

    printf("后序遍历:");
    LastOrder(NodeA);
    printf("\n");

    int size_of_totalNode = BinaryTreeSize_of_Node(NodeA);
    printf("当前二叉树的总结点个数为：%d", size_of_totalNode);
    printf("\n");

    int size_of_LeafNode = BinaryTreesize_of_Leaf(NodeA);
    printf("当前二叉树的叶子结点个数为：%d", size_of_LeafNode);
    printf("\n");

    int size_of_KNode = BinaryTreeSize_of_K(NodeA, 4);
    printf("当前二叉树的第 4 层的结点个数为：%d", size_of_KNode);
    printf("\n");

    int size_of_Depth = BinaryTreeSize_of_Depth(NodeA);
    printf("当前二叉树的层数为：%d", size_of_Depth);
    printf("\n");

    BinaryTreeSearch_of_val(NodeA, 'I');
    printf("层序遍历的结果为：");
    LevelOrder(NodeA);
    printf("\n");

    if (IsBinaryTree_of_Complete(NodeA)) {
        printf("一棵完全二叉树");
    } else {
        printf("这不是完全二叉树...\n");
    }
    return 0;
}

以上即为二叉树链式存储的核心实现与常用算法解析。