C++遍历树,前中后序,递归非递归实现


在这里插入图片描述

前序遍历

  • 递归思路:先访问根节点,然后递归遍历左子树,最后递归遍历右子树。
  • 非递归思路:使用栈来模拟递归过程。先将根节点入栈,之后循环执行以下操作:弹出栈顶元素并访问,若其右子节点存在则将右子节点入栈,若其左子节点存在则将左子节点入栈。

中序遍历

  • 递归思路:先递归遍历左子树,接着访问根节点,最后递归遍历右子树。
  • 非递归思路:利用栈。从根节点开始,持续将左子节点入栈,直至左子节点为空;接着弹出栈顶元素并访问,再将当前节点设为其右子节点,重复上述操作。

后序遍历

  • 递归思路:先递归遍历左子树,再递归遍历右子树,最后访问根节点。
  • 非递归思路:借助两个栈。第一个栈用于模拟递归调用,第二个栈用于存储最终的遍历结果。先将根节点压入第一个栈,之后循环:从第一个栈弹出节点并压入第二个栈,若该节点有左子节点则将左子节点压入第一个栈,若有右子节点则将右子节点压入第一个栈。最后从第二个栈依次弹出元素。

以下是完整的 C++ 代码实现:

#include <iostream>
#include <stack>
#include <vector>

// 定义二叉树节点结构
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

// 前序遍历 - 递归
void preorderTraversalRecursive(TreeNode* root, std::vector<int>& result) {
    if (root == nullptr) return;
    result.push_back(root->val);
    preorderTraversalRecursive(root->left, result);
    preorderTraversalRecursive(root->right, result);
}

// 前序遍历 - 非递归
std::vector<int> preorderTraversalIterative(TreeNode* root) {
    std::vector<int> result;
    if (root == nullptr) return result;
    std::stack<TreeNode*> stack;
    stack.push(root);
    while (!stack.empty()) {
        TreeNode* node = stack.top();
        stack.pop();
        result.push_back(node->val);
        if (node->right) stack.push(node->right);
        if (node->left) stack.push(node->left);
    }
    return result;
}

// 中序遍历 - 递归
void inorderTraversalRecursive(TreeNode* root, std::vector<int>& result) {
    if (root == nullptr) return;
    inorderTraversalRecursive(root->left, result);
    result.push_back(root->val);
    inorderTraversalRecursive(root->right, result);
}

// 中序遍历 - 非递归
std::vector<int> inorderTraversalIterative(TreeNode* root) {
    std::vector<int> result;
    std::stack<TreeNode*> stack;
    TreeNode* current = root;
    while (current != nullptr || !stack.empty()) {
        while (current != nullptr) {
            stack.push(current);
            current = current->left;
        }
        current = stack.top();
        stack.pop();
        result.push_back(current->val);
        current = current->right;
    }
    return result;
}

// 后序遍历 - 递归
void postorderTraversalRecursive(TreeNode* root, std::vector<int>& result) {
    if (root == nullptr) return;
    postorderTraversalRecursive(root->left, result);
    postorderTraversalRecursive(root->right, result);
    result.push_back(root->val);
}

// 后序遍历 - 非递归
std::vector<int> postorderTraversalIterative(TreeNode* root) {
    std::vector<int> result;
    if (root == nullptr) return result;
    std::stack<TreeNode*> stack1, stack2;
    stack1.push(root);
    while (!stack1.empty()) {
        TreeNode* node = stack1.top();
        stack1.pop();
        stack2.push(node);
        if (node->left) stack1.push(node->left);
        if (node->right) stack1.push(node->right);
    }
    while (!stack2.empty()) {
        result.push_back(stack2.top()->val);
        stack2.pop();
    }
    return result;
}

// 辅助函数:打印结果
void printResult(const std::vector<int>& result) {
    for (int val : result) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

int main() {
    // 构建一个简单的二叉树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);

    std::vector<int> result;

    // 前序遍历
    std::cout << "Preorder Traversal (Recursive): ";
    preorderTraversalRecursive(root, result);
    printResult(result);
    result.clear();

    std::cout << "Preorder Traversal (Iterative): ";
    result = preorderTraversalIterative(root);
    printResult(result);
    result.clear();

    // 中序遍历
    std::cout << "Inorder Traversal (Recursive): ";
    inorderTraversalRecursive(root, result);
    printResult(result);
    result.clear();

    std::cout << "Inorder Traversal (Iterative): ";
    result = inorderTraversalIterative(root);
    printResult(result);
    result.clear();

    // 后序遍历
    std::cout << "Postorder Traversal (Recursive): ";
    postorderTraversalRecursive(root, result);
    printResult(result);
    result.clear();

    std::cout << "Postorder Traversal (Iterative): ";
    result = postorderTraversalIterative(root);
    printResult(result);

    // 释放内存
    delete root->left->left;
    delete root->left->right;
    delete root->left;
    delete root->right;
    delete root;

    return 0;
}    

代码解释

  1. TreeNode 结构体:用于定义二叉树的节点,包含节点的值、左子节点指针和右子节点指针。
  2. 递归遍历函数preorderTraversalRecursiveinorderTraversalRecursivepostorderTraversalRecursive 分别实现了前序、中序和后序遍历的递归版本。
  3. 非递归遍历函数preorderTraversalIterativeinorderTraversalIterativepostorderTraversalIterative 分别实现了前序、中序和后序遍历的非递归版本。
  4. printResult 函数:用于打印遍历结果。
  5. main 函数:构建一个简单的二叉树,调用各个遍历函数并打印结果,最后释放二叉树占用的内存。

通过运行上述代码,你可以看到不同遍历方式的结果。

### 遍历的定义与实现 遍历是一种深度优搜索的方式,其访问顺为根节点、左子、右子[^3]。以下是基于递归非递归两种方式实现 Python 的二叉遍历。 #### 递归实现 递归方法是最直观的方式来实现遍历。通过依次调用函数本身来处理当节点及其左右子: ```python class TreeNode: def __init__(self, value): self.value = value self.left = None self.right = None def preorder_recursive(node): if node is not None: print(node.value) # 访问根节点 preorder_recursive(node.left) # 遍历左子 preorder_recursive(node.right) # 遍历右子 ``` 上述代码中,`preorder_recursive` 函数按照根节点 -> 左子 -> 右子的顺执行操作。 #### 非递归实现 非递归版本通常利用栈结构显式模拟递归过程。这种方法的核心思想是对递归逻辑的手动展开,从而避免隐式的函数调用开销[^2]。 ```python def preorder_iterative(root): stack = [] result = [] if root is not None: stack.append(root) while stack: node = stack.pop() if node is not None: result.append(node.value) # 处理当节点数据 if node.right is not None: # 压入右孩子(因为栈进后出) stack.append(node.right) if node.left is not None: # 后压入左孩子 stack.append(node.left) return result ``` 在此代码片段中,使用了一个列表 `stack` 来存储待访问的节点,并按相反顺压入右子和左子以确保正确的访问次。 ### 总结 无论是递归还是迭代的方法都可以有效地完成二叉遍历任务。递归形式更加简洁易懂,而迭代则提供了更灵活的空间管理能力,在某些场景下可能更具优势。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值