LeetCode_226 翻转二叉树

1、题目：翻转二叉树

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

2、解题思路

方法一：递归

1. 确定递归函数的参数和返回值，返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为TreeNode*。
2. 确定终止条件，当前节点为空的时候，就返回。
3. 确定单层递归的逻辑，因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。

方法二：迭代

在迭代遍历的基础上进行翻转

LeetCode_144 二叉树的前序遍历_W__winter的博客-CSDN博客

方法三：层序遍历

在层序遍历的基础上进行翻转

LeetCode_102 二叉树的层序遍历_W__winter的博客-CSDN博客

3、代码

//递归
class Solution 
{
public:
    TreeNode* invertTree(TreeNode* root) 
    {
        if (root == NULL) 
            return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

//迭代
class Solution 
{
public:
    TreeNode* invertTree(TreeNode* root) 
    {
        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:
    TreeNode* invertTree(TreeNode* root) 
    {
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) 
        {
            TreeNode* node = st.top();
            if (node != NULL) 
            {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            } 
            else 
            {
                st.pop();
                node = st.top();
                st.pop();
                swap(node->left, node->right);          // 节点处理逻辑
            }
        }
        return root;
    }
};

//层序遍历
class Solution 
{
public:
    TreeNode* invertTree(TreeNode* root) 
    {
        queue<TreeNode*> que;
        if (root != NULL) 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;
    }
};