代码随想录13天，二叉树递归遍历 、迭代遍历、统一迭代、层序遍历

1.二叉树递归遍历，熟悉自己构造二叉树。

// 二叉树递归遍历
#include <iostream>
#include <vector>

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

// 前序遍历函数
void preorderTraversalHelper(TreeNode *root, std::vector<int> &result)
{
    if (root == nullptr)
        return;                                   // 基本情况：如果节点为空，则返回
    result.push_back(root->val);                  // 访问根节点
    preorderTraversalHelper(root->left, result);  // 递归遍历左子树
    preorderTraversalHelper(root->right, result); // 递归遍历右子树
}

// 返回前序遍历结果的函数
std::vector<int> preorderTraversal(TreeNode *root)
{
    std::vector<int> result;
    preorderTraversalHelper(root, result);
    return result;
}

// 主函数用于测试
int main()
{
    // 构建一个简单的树: 1 -> 2 -> 3
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);

    std::vector<int> traversal = preorderTraversal(root);
    for (int value : traversal)
    {
        std::cout << value << " ";
    }
    return 0;
}

2.二叉树迭代遍历，熟悉一下用栈实现迭代遍历

// 二叉树迭代遍历，用堆实现
#include <iostream>
#include <vector>
#include <stack>

using namespace std;

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

// 用堆来实现迭代遍历
vector<int> preorderTraversal(TreeNode *root)
{
    stack<TreeNode *> st;
    vector<int> result;
    if (root == nullptr)
        return result;
    st.push(root);

    while (!st.empty())
    {
        TreeNode *node = st.top();
        st.pop();
        result.push_back(node->val);
        if (node->right)
            st.push(node->right);
        if (node->left)
            st.push(node->left);
    }

    return result;
}

// 注意中序遍历需要注意访问顺序和处理顺序的区别，后序遍历可以通过改变前序遍历反转得到
vector<int> inorderTraversal(TreeNode *root)
{
    vector<int> result;
    stack<TreeNode *> st;
    TreeNode *cur = root;
    while (cur != NULL || !st.empty())
    {
        if (cur != NULL)
        {                    // 指针来访问节点，访问到最底层
            st.push(cur);    // 将访问的节点放进栈
            cur = cur->left; // 左
        }
        else
        {
            cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
            st.pop();
            result.push_back(cur->val); // 中
            cur = cur->right;           // 右
        }
    }
    return result;
}

int main()
{
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);

    std::vector<int> res = preorderTraversal(root);
    for (int val : res)
    {
        std::cout << val << " ";
    }
    return 0;
}

3.统一迭代，针对迭代法不能用统一的操作实现不同顺序迭代的问题，使用添加了操作标志的结构体来实现，代码如下：

// 针对迭代法实现二叉树三种遍历时不能统一风格的问题，可以加一个标志位标志操作的性质来实现
#include <iostream>
#include <stack>
#include <vector>

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

// 用于标记操作的枚举类型
enum Action
{
    ADD,
    PRINT
};

// 操作的结构体，包含一个操作和一个节点
struct Command
{
    Action action;
    TreeNode *node;
};

// 三种遍历的统一函数
std::vector<int> traverse(TreeNode *root, const std::string &order)
{
    std::vector<int> result;
    if (!root)
        return result;

    std::stack<Command> stack;
    stack.push({ADD, root});

    while (!stack.empty())
    {
        Command cmd = stack.top();
        stack.pop();

        if (cmd.node == nullptr)
            continue;
        if (cmd.action == PRINT)
        {
            result.push_back(cmd.node->val);
        }
        else
        {
            if (order == "postorder")
            {
                stack.push({PRINT, cmd.node});
                stack.push({ADD, cmd.node->right});
                stack.push({ADD, cmd.node->left});
            }
            else if (order == "inorder")
            {
                stack.push({ADD, cmd.node->right});
                stack.push({PRINT, cmd.node});
                stack.push({ADD, cmd.node->left});
            }
            else
            { // preorder
                stack.push({ADD, cmd.node->right});
                stack.push({ADD, cmd.node->left});
                stack.push({PRINT, cmd.node});
            }
        }
    }
    return result;
}

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> preorder = traverse(root, "preorder");
    std::cout << "Preorder: ";
    for (int val : preorder)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // 中序遍历
    std::vector<int> inorder = traverse(root, "inorder");
    std::cout << "Inorder: ";
    for (int val : inorder)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // 后序遍历
    std::vector<int> postorder = traverse(root, "postorder");
    std::cout << "Postorder: ";
    for (int val : postorder)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

4.比较简单的层序遍历

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

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

vector<int> levelOrder(TreeNode *root)
{

    vector<int> result;
    if (root == nullptr)
        return result;

    queue<TreeNode *> queue;
    queue.push(root);

    while (!queue.empty()) 
    {
        TreeNode *node = queue.front();
        queue.pop();

        result.push_back(node->val);

        if (node->left)
            queue.push(node->left);
        if (node->right)
            queue.push(node->right);
    }
    return result;
}

vector<vector<int>> levelOrder2(TreeNode *root)
{

    vector<vector<int>> result;
    queue<TreeNode *> queue;
    if (root != nullptr)
        queue.push(root);

    while (!queue.empty()) // 如果要按照层来划分的话，需要加一个for循环
    {
        int size = queue.size();
        vector<int> vec;
        for (int i = 0; i < size; i++)
        {
            TreeNode *node = queue.front();
            queue.pop();
            vec.push_back(node->val);
            if (node->left)
                queue.push(node->left);
            if (node->right)
                queue.push(node->right);
        }
        result.push_back(vec);
    }
    return result;
}

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 = levelOrder(root);
    std::cout << "Level order traversal: ";
    for (int val : result)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}