C语言基于结构体与循环构建树时，如何避免分支返回终止fn_01的无限循环

核心逻辑偏差 #

你现在遇到的问题本质是代码结构上的操作绑定错位，不是C语言语法不支持：
你原本的逻辑里，在fn_01的循环内拿到fn_02/fn_03返回的单个节点后，直接把这个节点作为fn_01的返回值向外抛——只要执行return，必然终止当前函数和所在的循环，这是C语言的固定执行逻辑，没有办法绕过。
要同时满足「循环持续运行拼树」「拿到子节点不丢」「最终返回完整树」的需求，只需要把“单次拿取子节点”和“整个函数返回整树”这两个操作解耦就行，下面是两个可直接落地的改造方案，完全兼容你现有的代码结构。

方案1：循环内拼接节点，仅在树构建完成时退出循环返回 #

这是最贴合你现有设计的改造方式，不需要推翻原有逻辑，仅修正“拿到节点就直接return出fn_01”的问题：

• 在fn_01内部维护两个状态变量：已构建部分的树的根节点指针、当前正在挂载子节点的游标指针
• switch分支内拿到fn_02/fn_03返回的节点后，不执行return操作，直接把节点挂到当前树的对应位置，再进入下一轮循环
• 新增树构建完成的判定分支，收到结束信号后跳出无限循环，此时再把完整的树根节点返回

改造后的核心代码参考：

// 补全树节点的必要定义，struct sample必须包含孩子指针才能完成树拼接
struct sample {
    int node_val;
    struct sample *left_child;
    struct sample *right_child;
};

struct sample *fn_01(void) {
    struct sample *tree_root = NULL;
    struct sample *build_cursor = NULL; // 标记当前要挂子节点的位置
    int build_finish = 0;

    for(;;) {
        switch(你的原有switch判定逻辑) {
            case 1: {
                // 先拿fn02返回的节点，不直接return
                struct sample *new_node = fn_02();
                // 根据你的树构建规则挂载节点，这里以层序构建为例
                if (tree_root == NULL) {
                    tree_root = new_node;
                    build_cursor = new_node;
                } else if (build_cursor->left_child == NULL) {
                    build_cursor->left_child = new_node;
                } else {
                    build_cursor->right_child = new_node;
                    build_cursor = new_node; // 移动游标，继续往深层构建
                }
                break;
            }
            case 2: {
                struct sample *new_node = fn_03();
                // 同理挂载节点，不退出循环
                if (tree_root == NULL) {
                    tree_root = new_node;
                    build_cursor = new_node;
                } else if (build_cursor->left_child == NULL) {
                    build_cursor->left_child = new_node;
                } else {
                    build_cursor->right_child = new_node;
                    build_cursor = new_node;
                }
                break;
            }
            case 3:
                // 新增结束分支，标记树构建完成
                build_finish = 1;
                break;
        }
        // 满足完成条件就跳出无限循环
        if (build_finish) break;
    }
    // 此时才返回完整的树结构
    return tree_root;
}

⚠️ 顺带修正你原有代码的隐藏问题：fn_02/fn_03里现在定义的struct sample *node是未初始化的局部栈指针，直接返回会触发野指针崩溃，必须手动给节点分配堆内存、初始化指针成员：

struct sample *fn_02(void) {
    // 为节点分配堆内存
    struct sample *node = malloc(sizeof(struct sample));
    node->node_val = 2;
    node->left_child = node->right_child = NULL;
    return node;
}

方案2：需要持续产出节点不终止函数时，用回调替代直接return #

如果你不需要等整棵树拼完才返回，而是希望fn_01的循环持续运行，每拿到fn_02/fn_03返回的节点就传给外部逻辑处理，那就不能靠return传递节点（因为return会终止函数），可以通过传入回调函数的方式把节点递出去，同时保持循环运行：

// 定义回调函数类型：接收一个树节点指针，无返回值
typedef void (*node_handle_func)(struct sample *node);

struct sample *fn_01(node_handle_func handle_cb) {
    struct sample *tree_root = NULL;
    for(;;) {
        switch(你的原有switch判定逻辑) {
            case 1: {
                struct sample *new_node = fn_02();
                // 把节点传给外部逻辑处理，不触发return
                if (handle_cb != NULL) handle_cb(new_node);
                // 本地同步维护树结构
                if (tree_root == NULL) tree_root = new_node;
                break;
            }
            case 2: {
                struct sample *new_node = fn_03();
                if (handle_cb != NULL) handle_cb(new_node);
                if (tree_root == NULL) tree_root = new_node;
                break;
            }
        }
        // 注意：无限循环必须加明确的退出判定（比如收到外部终止信号），否则会一直占满CPU
    }
    return tree_root;
}

// main函数里传入自己的节点处理逻辑即可
void save_node_to_queue(struct sample *node) {
    // 这里写你拿到节点之后要做的操作，比如入队、拼接树
}
int main() {
    struct sample *full_tree = fn_01(save_node_to_queue);
}

如果你的场景是要和其他模块并行运行fn_01的循环，还可以把fn_01放到独立线程里，通过共享的上下文结构体传递拿到的节点，加互斥锁保证读写安全即可。

内容的提问来源于stack exchange，提问作者Lasan Nishshanka