二叉树的递归与非递归遍历：C++实现

在数据结构的学习中，二叉树是一个非常重要的概念。遍历二叉树是理解和操作二叉树的基础。本文将介绍如何使用C++实现二叉树的递归和非递归遍历，包括前序、中序和后序遍历，并对每种遍历方法的原理进行简要介绍。

二叉树节点定义

首先，我们定义一个简单的二叉树节点结构：

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

递归遍历二叉树

递归遍历是一种直观且易于实现的方法。以下是使用递归实现的前序、中序和后序遍历函数：

using namespace std;

// 递归前序遍历原理：首先访问根节点，然后递归遍历左子树，最后递归遍历右子树。
void preOrderRecursive(TreeNode* node) {
    if (node == nullptr) return;
    cout << node->val << " ";  // 访问当前节点
    preOrderRecursive(node->left);  // 遍历左子树
    preOrderRecursive(node->right); // 遍历右子树
}

// 递归中序遍历原理：首先递归遍历左子树，然后访问根节点，最后递归遍历右子树。
void inOrderRecursive(TreeNode* node) {
    if (node == nullptr) return;
    inOrderRecursive(node->left);  // 遍历左子树
    cout << node->val << " ";  // 访问当前节点
    inOrderRecursive(node->right); // 遍历右子树
}

// 递归后序遍历原理：首先递归遍历左子树，然后递归遍历右子树，最后访问根节点。
void postOrderRecursive(TreeNode* node) {
    if (node == nullptr) return;
    postOrderRecursive(node->left);  // 遍历左子树
    postOrderRecursive(node->right); // 遍历右子树
    cout << node->val << " ";  // 访问当前节点
}

非递归遍历二叉树

非递归遍历通常使用栈来实现。以下是使用非递归方法实现的前序、中序和后序遍历函数：

// 非递归前序遍历原理：使用栈模拟递归的压栈过程，首先遍历到树的最左端，然后逐个弹出节点并访问。
void preOrderNonRecursive(TreeNode* root) {
    stack<TreeNode*> stack;
    TreeNode* current = root;

    while (current != nullptr || !stack.empty()) {
        if (current != nullptr) {
            cout << current->val << " ";
            stack.push(current);
            current = current->left;
        } else {
            current = stack.top();
            stack.pop();
            current = current->right;
        }
    }
}

// 非递归中序遍历原理：使用栈记录遍历路径，首先遍历到最左端，然后回溯访问节点并继续遍历右子树。
void inOrderNonRecursive(TreeNode* root) {
    stack<TreeNode*> stack;
    TreeNode* current = root;

    while (current != nullptr) {
        stack.push(current);
        current = current->left;
    }

    while (!stack.empty()) {
        current = stack.top();
        stack.pop();
        cout << current->val << " ";
        current = current->right;
        while (current != nullptr) {
            stack.push(current);
            current = current->left;
        }
    }
}

// 非递归后序遍历原理：使用两个栈来分别记录节点的遍历顺序和访问顺序，以实现最后访问根节点。
void postOrderNonRecursive(TreeNode* root) {
    stack<TreeNode*> s1, s2;
    TreeNode* current = root;

    while (current != nullptr) {
        s1.push(current);
        current = current->left;
    }

    while (!s1.empty()) {
        current = s1.top();
        s1.pop();
        s2.push(current);
        if (current->right != nullptr) {
            current = current->right;
            while (current != nullptr) {
                s1.push(current);
                current = current->left;
            }
        }
    }

    while (!s2.empty()) {
        current = s2.top();
        s2.pop();
        cout << current->val << " ";
    }
}

测试代码

为了验证上述遍历函数的正确性，我们可以创建一个简单的二叉树并调用这些函数：

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);

    // 递归遍历
    cout << "递归前序遍历: ";
    preOrderRecursive(root);
    cout << endl;

    cout << "递归中序遍历: ";
    inOrderRecursive(root);
    cout << endl;

    cout << "递归后序遍历: ";
    postOrderRecursive(root);
    cout << endl;

    // 非递归遍历
    cout << "非递归前序遍历: ";
    preOrderNonRecursive(root);
    cout << endl;

    cout << "非递归中序遍历: ";
    inOrderNonRecursive(root);
    cout << endl;

    cout << "非递归后序遍历: ";
    postOrderNonRecursive(root);
    cout << endl;

    return 0;
}

结语

递归和非递归遍历是二叉树操作中的基础技能。递归方法简洁易懂，但可能会遇到栈溢出的问题；非递归方法虽然代码复杂一些，但可以避免递归带来的问题。理解这两种方法的原理和实现，对于深入学习数据结构和算法非常有帮助。

希望这篇文章能帮助你更好地理解二叉树的遍历方法。如果你有任何问题或建议，请在评论区告诉我。感谢阅读！