翻转二叉树学习笔记（leetcode226）

问题描述

传送门

思路

我们之前学的都是各种方式遍历二叉树，而这次呢，是要翻转二叉树。
那怎么翻转呢？
如果要从整个树来看，翻转真的挺复杂，整个数以中间线进行翻转，如下图：

可以发现，如果要翻转它，就是把每一个节点的左右孩子节点交换一下就可以了。
（注意:孩子下面的节点是一起交换的)
那这个时候，我们要思考一下，前中后序应该选哪一种遍历顺序？
得出方法论：
使用前序遍历和后序遍历都可以， 唯独中序遍历不行，因为中序遍历会把某些节点的左右孩子翻转了两次！
建议拿纸画一画，就理解了
那么层序遍历可不可以呢？
依然可以， 只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的。

递归方法实现

以前序遍历为例，我们通过动画来看一下翻转的过程：
图解动画下载地址

再来回顾一下递归的三部曲：

1、确定递归函数的参数和返回值

①参数就是要传入节点的指针，如果在写递归的逻辑中发现还需要其他参数的时候，随时补充。
②返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以函数的返回类型为 TreeNode*

TreeNode* invertTree(TreeNode* root)

2、确定终止条件

当前节点为空，就返回

if (root == NULL) return root;

3、确定每层递归的逻辑

在前序遍历中，先进行交换左右孩子节点，然后翻转左子树，最后反转右子树。

swap(root->left, root->right);
invertTree(root->left);
invertTree(root->right);

C++基本逻辑思路就如下了：

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

把之前学到的知识，像串糖葫芦串一样，完完整整的串了一遍。
真的好开心哦~