《代码随想录》第六章二叉树 226. 翻转二叉树-优快云博客

本文链接：https://blog.youkuaiyun.com/ii_fan/article/details/145951301

《代码随想录》第六章二叉树 226. 翻转二叉树

努力学习！

题目：力扣链接

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

一、思想

核心思想是通过迭代或递归的方式，交换二叉树的每个节点的左右子节点，从而完成整棵树的翻转。无论是递归法、前序遍历法、后序遍历法还是层序遍历法，本质都是遍历树的每个节点并交换其左右子节点。

二、代码

递归法

class Solution
{
public:
    /**
     * 翻转二叉树的函数
     * @param root 二叉树的根节点
     * @return 翻转后的二叉树的根节点
     */
    TreeNode *invertTree(TreeNode *root)
    {
        /**
         * 方法1：递归
         */
        // 如果根节点为空，则直接返回
        if (root == NULL) {
            return root;
        }
        // 交换根节点的左右子节点
        TreeNode *temp = root->left;
        root->left = root->right;
        root->right = temp;
        // 递归翻转左右子树
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

前序遍历法

class Solution
{
public:
    /**
     * 翻转二叉树的函数
     * @param root 二叉树的根节点
     * @return 翻转后的二叉树的根节点
     */
    TreeNode *invertTree(TreeNode *root)
    {
        /**
         * 方法2：前序遍历
         */
        // 如果根节点为空，则直接返回
        if (root == NULL) {
            return root;
        }
        // 使用栈进行翻转
        stack<TreeNode *> st;
        st.push(root);
        while (!st.empty()) {
            TreeNode *node = st.top();
            st.pop();
            // 交换当前节点的左右子节点
            swap(node->left, node->right);
            // 如果右子节点存在，则入栈
            if (node->right) {
                st.push(node->right);
            }
            // 如果左子节点存在，则入栈
            if (node->left) {
                st.push(node->left);
            }
        }
        return root;
    }
};

后序遍历法

class Solution
{
public:
    /**
     * 翻转二叉树的函数
     * @param root 二叉树的根节点
     * @return 翻转后的二叉树的根节点
     */
    TreeNode *invertTree(TreeNode *root)
    {
        /**
         * 方法3：后序遍历
         */
        // 如果根节点为空，则直接返回
        if (root == NULL) {
            return root;
        }
        // 使用栈进行翻转
        stack<TreeNode *> st;
        st.push(root);
        while (!st.empty()) {
            TreeNode *node = st.top();
            st.pop();
            // 如果右子节点存在，则入栈
            if (node->right) {
                st.push(node->right);
            }
            // 如果左子节点存在，则入栈
            if (node->left) {
                st.push(node->left);
            }
            // 交换当前节点的左右子节点
            swap(node->left, node->right);
        }
        return root;
    }
};

层序遍历法

class Solution
{
public:
    /**
     * 翻转二叉树的函数
     * @param root 二叉树的根节点
     * @return 翻转后的二叉树的根节点
     */
    TreeNode *invertTree(TreeNode *root)
    {
        /**
         * 方法4:层序遍历
         */
        // 如果根节点为空，则直接返回
        if (root == NULL) {
            return root;
        }
        // 使用队列进行翻转
        queue<TreeNode *> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; ++i) {
                TreeNode *node = que.front();
                que.pop();
                // 交换当前节点的左右子节点
                swap(node->left, node->right);
                // 如果左子节点存在，则入队
                if (node->left) {
                    que.push(node->left);
                }
                // 如果右子节点存在，则入队
                if (node->right) {
                    que.push(node->right);
                }
            }
        }
        return root;
    }
};