二叉树递归复制：前序与后序实现对比

1. 递归复制二叉树的核心逻辑

二叉树复制是数据结构中的基础操作，递归实现尤其能体现分治思想。我们先看最直观的写法——前序递归复制：

c复制// 二叉树节点结构体定义
typedef struct BiTNode {
    char data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

// 前序递归复制
BiTree CopyTree_PreOrder(BiTree original) {
    if (original == NULL) return NULL;
    
    // 创建新节点（相当于前序遍历的"访问"操作）
    BiTree new_node = (BiTree)malloc(sizeof(BiTNode));
    if (!new_node) exit(OVERFLOW);
    new_node->data = original->data;
    
    // 递归复制左右子树
    new_node->lchild = CopyTree_PreOrder(original->lchild);
    new_node->rchild = CopyTree_PreOrder(original->rchild);
    
    return new_node;
}

这种写法的特点是"先创建父节点，再处理子节点"，符合前序遍历的根-左-右顺序。但递归深度与树高成正比，当树高较大时可能导致栈溢出。

2. 后序递归的优化实现

后序递归版本将节点创建操作放在递归之后，虽然执行顺序不同，但最终效果一致：

c复制BiTree CopyTree_PostOrder(BiTree original) {
    if (original == NULL) return NULL;
    
    // 先递归处理子树
    BiTree left_copy = CopyTree_PostOrder(original->lchild);
    BiTree right_copy = CopyTree_PostOrder(original->rchild);
    
    // 最后创建当前节点（相当于后序遍历的"访问"操作）
    BiTree new_node = (BiTree)malloc(sizeof(BiTNode));
    if (!new_node) exit(OVERFLOW);
    new_node->data = original->data;
    new_node->lchild = left_copy;
    new_node->rchild = right_copy;
    
    return new_node;
}

后序版本的优势在于：

1. 内存分配更集中，可能减少内存碎片
2. 某些编译器对尾递归优化更友好
3. 处理异常时更容易释放已分配内存

3. 两种实现的性能对比测试

我们构建深度为10的满二叉树进行测试：

测试结果显示：

• 递归版本的时间复杂度均为O(n)
• 后序版本内存占用略优
• 栈深度与树高相同

4. 递归实现的边界条件处理

实际应用中需要考虑的特殊情况：

c复制// 带错误检查的增强版本
BiTree CopyTree_Safe(BiTree original) {
    if (original == NULL) return NULL;
    
    BiTree new_node = NULL;
    BiTree left_copy = NULL;
    BiTree right_copy = NULL;
    
    // 先复制子树
    left_copy = CopyTree_Safe(original->lchild);
    if (original->lchild && !left_copy) goto error;
    
    right_copy = CopyTree_Safe(original->rchild);
    if (original->rchild && !right_copy) goto error;
    
    // 再创建当前节点
    new_node = (BiTree)malloc(sizeof(BiTNode));
    if (!new_node) goto error;
    
    new_node->data = original->data;
    new_node->lchild = left_copy;
    new_node->rchild = right_copy;
    
    return new_node;
    
error:
    FreeTree(left_copy);  // 自定义的树释放函数
    FreeTree(right_copy);
    return NULL;
}

这种实现确保了：

1. 内存分配失败时能正确回滚
2. 不会因为部分失败导致内存泄漏
3. 保持原始树的完整性不被破坏

5. 递归与非递归的转换思路

虽然递归实现简洁，但理解其对应的非递归形式很有必要。以前序递归为例，可以转换为显式栈实现：

c复制BiTree CopyTree_Stack(BiTree original) {
    if (!original) return NULL;
    
    Stack s; InitStack(&s);
    BiTree new_root = NULL;
    Push(&s, original);
    
    // 用于建立父子关系的辅助栈
    Stack parent_stack; InitStack(&parent_stack);
    
    while (!StackEmpty(s)) {
        BiTree curr = Pop(&s);
        BiTree new_node = (BiTree)malloc(sizeof(BiTNode));
        if (!new_node) exit(OVERFLOW);
        
        new_node->data = curr->data;
        new_node->lchild = new_node->rchild = NULL;
        
        if (!new_root) {
            new_root = new_node;
        } else {
            BiTree parent = Peek(parent_stack);
            if (!parent->lchild) {
                parent->lchild = new_node;
            } else {
                parent->rchild = new_node;
                Pop(&parent_stack);  // 右孩子处理完，父节点出栈
            }
        }
        
        // 右孩子先入栈（保证出栈顺序是左孩子先处理）
        if (curr->rchild) Push(&s, curr->rchild);
        if (curr->lchild) {
            Push(&s, curr->lchild);
            Push(&parent_stack, new_node);  // 新节点作为父节点入栈
        }
    }
    return new_root;
}

这个实现虽然代码量增加，但完全避免了递归的栈溢出风险，适合深度未知的大树复制场景。

6. 递归复制在复杂数据结构中的应用

二叉树复制思想可以扩展到更复杂的数据结构。例如复制带父指针的二叉树：

c复制typedef struct PBNode {
    int data;
    struct PBNode *lchild, *rchild, *parent;
} PBNode, *PBiTree;

PBiTree CopyPBiTree(PBiTree original, PBNode *parent) {
    if (!original) return NULL;
    
    PBiTree new_node = (PBiTree)malloc(sizeof(PBNode));
    if (!new_node) exit(OVERFLOW);
    
    new_node->data = original->data;
    new_node->parent = parent;  // 设置父指针
    
    new_node->lchild = CopyPBiTree(original->lchild, new_node);
    new_node->rchild = CopyPBiTree(original->rchild, new_node);
    
    return new_node;
}

这种扩展实现的关键点在于：

1. 增加了parent指针参数
2. 在递归调用时传入当前新建节点作为子节点的parent
3. 保持了原始树的父节点关系

7. 递归复制中的内存管理技巧

在递归操作中正确处理内存至关重要。以下是几个实用技巧：

1. 内存分配检查：每次malloc后立即检查返回值

c复制new_node = (BiTree)malloc(sizeof(BiTNode));
if (!new_node) {
    perror("Memory allocation failed");
    exit(EXIT_FAILURE);
}

2. 优雅的错误恢复：使用goto集中处理错误

c复制error:
    if (left) FreeTree(left);
    if (right) FreeTree(right);
    return NULL;

3. 内存池优化：预分配节点减少malloc调用

c复制#define POOL_SIZE 1000
BiTNode node_pool[POOL_SIZE];
int pool_index = 0;

BiTree GetNode() {
    if (pool_index >= POOL_SIZE) return NULL;
    return &node_pool[pool_index++];
}

void InitPool() {
    pool_index = 0;
}

4. 引用计数：复杂场景下的内存管理

c复制typedef struct {
    BiTree tree;
    int ref_count;
} TreeWithRef;

TreeWithRef* CopyTreeWithRef(TreeWithRef* original) {
    if (!original) return NULL;
    original->ref_count++;
    return original;
}

这些技巧可以根据实际场景组合使用，特别是在嵌入式系统等资源受限环境中尤为重要。