二叉树的迭代遍历（C++实现）

C++迭代实现二叉树的前序遍历、中序遍历和后序遍历

1. 二叉树的创建

struct TreeNode {
    TreeNode() : m_val(0), m_left_node(NULL), m_right_node(NULL) { }
    TreeNode(int val) : m_val(val), m_left_node(NULL), m_right_node(NULL) { }
    TreeNode(int val, TreeNode* left_node, TreeNode* right_node) : m_val(val), m_left_node(left_node), m_right_node(right_node) { }
    int m_val;
    TreeNode* m_left_node;
    TreeNode* m_right_node;
};

2.迭代遍历方法类实现

class Solution {
public:
    std::vector<int> Traversal(TreeNode* root) {
        std::vector<int> result;
        TraversalResult3(root, result);
        return result;
    }

    // 前序遍历——中左右
    void TraversalResult1(TreeNode* root, std::vector<int>& result) {
        std::stack<TreeNode*> stack;
        if (!root) return;
        stack.push(root);
        while (!stack.empty()) {
            // 1. 取出中间节点，放入结果集
            TreeNode* cur_node = stack.top();
            stack.pop();
            result.push_back(cur_node->m_val);
            // 2. 先压入右边子节点，保证左边先出栈
            if (cur_node->m_right_node) stack.push(cur_node->m_right_node);
            // 3. 后压入左边子节点，保证左边先出栈
            if (cur_node->m_left_node) stack.push(cur_node->m_left_node);
        }
    }

    // 中序遍历——左中右
    void TraversalResult2(TreeNode* root, std::vector<int>& result) {
        std::stack<TreeNode*> stack;
        if (!root) return;
        TreeNode* cur_node = root;
        while (cur_node || !stack.empty()) {
            // 1. 加入左侧节点
            if (cur_node) {
                stack.push(cur_node);
                cur_node = cur_node->m_left_node;
            }
            else {
                // 2. 取出节点，加入结果集
                cur_node = stack.top();
                stack.pop();
                result.push_back(cur_node->m_val);
                // 3. 遍历右侧节点
                cur_node = cur_node->m_right_node;
            }
        }
    }

    // 后序遍历——左右中
    void TraversalResult3(TreeNode* root, std::vector<int>& result) {
        std::stack<TreeNode*> stack;
        if (!root) return;
        stack.push(root);
        // 首先先按 中右左 的顺序放入结果集
        while (!stack.empty()) {
            // 1. 取出中间节点，放入结果集
            TreeNode* cur_node = stack.top();
            stack.pop();
            result.push_back(cur_node->m_val);
            // 2. 后压入左边子节点，保证左边先出栈
            if (cur_node->m_left_node) stack.push(cur_node->m_left_node);
            // 3. 先压入右边子节点，保证左边先出栈
            if (cur_node->m_right_node) stack.push(cur_node->m_right_node);
        }
        // vector反序
        ReVector(result);
    }

    // vector反序
    void ReVector(std::vector<int>& result) {
        int start = 0, end = result.size() - 1;
        while (start <= end) {
            int tmp = result[end];
            result[end] = result[start];
            result[start] = tmp;
            start++;
            end--;
        }
    }

    // 释放资源
    void FreeSpace(TreeNode* root) {
        if (!root) return;
        if (root->m_left_node) FreeSpace(root->m_left_node);
        if (root->m_right_node) FreeSpace(root->m_right_node);
        delete root;
    }
};

3.整体代码

/*
    1. 给你二叉树的根节点 root ，返回它节点值的前序遍历。
    2. 给你二叉树的根节点 root ，返回它节点值的中序遍历。
    3. 给你二叉树的根节点 root ，返回它节点值的后序遍历。
*/
#include <iostream>
#include <vector>
#include <stack>

// 二叉树结构体
struct TreeNode {
    TreeNode() : m_val(0), m_left_node(NULL), m_right_node(NULL) { }
    TreeNode(int val) : m_val(val), m_left_node(NULL), m_right_node(NULL) { }
    TreeNode(int val, TreeNode* left_node, TreeNode* right_node) : m_val(val), m_left_node(left_node), m_right_node(right_node) { }
    int m_val;
    TreeNode* m_left_node;
    TreeNode* m_right_node;
};


class Solution {
public:
    std::vector<int> Traversal(TreeNode* root) {
        std::vector<int> result;
        TraversalResult3(root, result);
        return result;
    }

    // 前序遍历——中左右
    void TraversalResult1(TreeNode* root, std::vector<int>& result) {
        std::stack<TreeNode*> stack;
        if (!root) return;
        stack.push(root);
        while (!stack.empty()) {
            // 1. 取出中间节点，放入结果集
            TreeNode* cur_node = stack.top();
            stack.pop();
            result.push_back(cur_node->m_val);
            // 2. 先压入右边子节点，保证左边先出栈
            if (cur_node->m_right_node) stack.push(cur_node->m_right_node);
            // 3. 后压入左边子节点，保证左边先出栈
            if (cur_node->m_left_node) stack.push(cur_node->m_left_node);
        }
    }

    // 中序遍历——左中右
    void TraversalResult2(TreeNode* root, std::vector<int>& result) {
        std::stack<TreeNode*> stack;
        if (!root) return;
        TreeNode* cur_node = root;
        while (cur_node || !stack.empty()) {
            // 1. 加入左侧节点
            if (cur_node) {
                stack.push(cur_node);
                cur_node = cur_node->m_left_node;
            }
            else {
                // 2. 取出节点，加入结果集
                cur_node = stack.top();
                stack.pop();
                result.push_back(cur_node->m_val);
                // 3. 遍历右侧节点
                cur_node = cur_node->m_right_node;
            }
        }
    }

    // 后序遍历——左右中
    void TraversalResult3(TreeNode* root, std::vector<int>& result) {
        std::stack<TreeNode*> stack;
        if (!root) return;
        stack.push(root);
        // 首先先按 中右左 的顺序放入结果集
        while (!stack.empty()) {
            // 1. 取出中间节点，放入结果集
            TreeNode* cur_node = stack.top();
            stack.pop();
            result.push_back(cur_node->m_val);
            // 2. 后压入左边子节点，保证左边先出栈
            if (cur_node->m_left_node) stack.push(cur_node->m_left_node);
            // 3. 先压入右边子节点，保证左边先出栈
            if (cur_node->m_right_node) stack.push(cur_node->m_right_node);
        }
        // vector反序
        ReVector(result);
    }

    // vector反序
    void ReVector(std::vector<int>& result) {
        int start = 0, end = result.size() - 1;
        while (start <= end) {
            int tmp = result[end];
            result[end] = result[start];
            result[start] = tmp;
            start++;
            end--;
        }
    }

    // 释放资源
    void FreeSpace(TreeNode* root) {
        if (!root) return;
        if (root->m_left_node) FreeSpace(root->m_left_node);
        if (root->m_right_node) FreeSpace(root->m_right_node);
        delete root;
    }
};


int main() {
    // 定义一棵树
    TreeNode* root = new TreeNode(5, new TreeNode(6, new TreeNode(8), NULL), new TreeNode(7, NULL, new TreeNode(9)));
    Solution solution;
    std::vector<int> result = solution.Traversal(root);
    for (int i = 0; i < result.size(); ++i) std::cout << result[i] << " ";
    std::cout << std::endl;
    // 释放资源
    solution.FreeSpace(root);
    return 0;
}