将Binary Tree存入vector并输出验证功能的技术求助

嘿，作为刚入门CS的新手，碰到二叉树转vector这种问题太正常了——我当年第一次写的时候也踩了好几个坑！别着急，咱们一步步来解决。

要把二叉树元素放进vector，本质就是遍历二叉树，把每个节点的值依次插入vector里。常见的遍历方式有四种：前序、中序、后序、层序，你可以根据需求选择。但很多新手踩的最致命的坑是：传递vector时用了值传递，而非引用传递——这样函数里修改的只是vector的副本，原vector根本不会有变化！

1. 完整示例框架（先对齐你的代码结构） #

假设你的二叉树节点定义是这样的（如果和你的不一样，直接调整类型即可）：

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

方法一：递归遍历（简单易写，适合小规模树） #

这里以中序遍历为例（二叉搜索树的中序遍历是有序的，最常用），注意vector必须传引用：

// 中序遍历逻辑：左子树 -> 当前节点 -> 右子树
void inorderTraversal(TreeNode* root, vector<int>& result) {
    if (root == nullptr) {
        return; // 空节点直接返回，避免访问空指针崩溃
    }
    inorderTraversal(root->left, result);
    result.push_back(root->val); // 把当前节点值加入vector
    inorderTraversal(root->right, result);
}

如果需要前序（根->左->右），就把push_back放在函数最开头；后序（左->右->根）放在最后，逻辑完全通用。

方法二：迭代遍历（避免递归栈溢出，适合大树） #

如果树的深度很大，递归可能触发栈溢出，这时候用迭代更安全，还是以中序为例：

vector<int> inorderIterative(TreeNode* root) {
    vector<int> result;
    stack<TreeNode*> stk;
    TreeNode* curr = root;
    
    while (curr != nullptr || !stk.empty()) {
        // 先遍历到当前分支的最左节点
        while (curr != nullptr) {
            stk.push(curr);
            curr = curr->left;
        }
        curr = stk.top();
        stk.pop();
        result.push_back(curr->val);
        curr = curr->right; // 处理右子树
    }
    return result;
}

方法三：层序遍历（按树的层次从上到下存储） #

如果你想按树的层级顺序存元素（比如从上到下、从左到右），用队列实现：

vector<int> levelOrder(TreeNode* root) {
    vector<int> result;
    if (root == nullptr) return result;
    
    queue<TreeNode*> q;
    q.push(root);
    
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        result.push_back(node->val);
        
        // 左孩子先入队，保证层次顺序
        if (node->left != nullptr) q.push(node->left);
        if (node->right != nullptr) q.push(node->right);
    }
    return result;
}

2. 输出vector内容验证 #

填充好vector后，输出就很简单了，直接遍历打印：

void printVector(const vector<int>& vec) {
    cout << "Vector内容：";
    for (int num : vec) {
        cout << num << " ";
    }
    cout << endl;
}

3. 完整测试流程 #

把这些代码拼起来，测试一个简单的二叉树：

int main() {
    // 构建测试二叉树：
    //     1
    //      \
    //       2
    //      /
    //     3
    TreeNode* root = new TreeNode(1);
    root->right = new TreeNode(2);
    root->right->left = new TreeNode(3);
    
    // 递归中序遍历测试
    vector<int> res;
    inorderTraversal(root, res);
    printVector(res); // 预期输出：1 3 2
    
    // 迭代中序遍历测试
    vector<int> resIter = inorderIterative(root);
    printVector(resIter); // 同样输出：1 3 2
    
    // 层序遍历测试
    vector<int> resLevel = levelOrder(root);
    printVector(resLevel); // 预期输出：1 2 3
    
    // 别忘了释放树的内存（新手容易忽略，避免内存泄漏）
    // 可以写个辅助函数：void deleteTree(TreeNode* root) { ... }
    
    return 0;
}

你可能踩过的坑复盘 #

• vector传值而非引用：如果函数写成void inorder(TreeNode* root, vector<int> result)，函数里修改的是副本，原vector不会有变化，一定要加&！
• 未判断空节点：访问root->val前必须检查root != nullptr，否则会触发空指针错误。
• 树的初始化错误：如果节点的left/right指针没设为nullptr，遍历会出现不可预期的错误。

内容的提问来源于stack exchange，提问作者Richard Sebestyen