<LeetCode OJ> 226. Invert Binary Tree

226. Invert Binary Tree

Total Accepted: 57653 Total
Submissions: 136144 Difficulty: Easy

Invert a binary tree.

     4
   /   \
  2     7
 / \   / \
1   3 6   9

to

     4
   /   \
  7     2
 / \   / \
9   6 3   1

Trivia:

This problem was inspired by this original tweet by Max
Howell:

Google: 90% of our engineers use the software you wrote (Homebrew), but you can’t invert a binary tree on a whiteboard so fuck off.

分析：

下面是别人家的算法：

自己当时实在没想清楚依据给定的代码形式怎样写出反转程序。这里是对其的自我分析。

1，朴素的递归思想：

1）。函数返回值怎样构成原问题的解

明白函数意义，

将根节点root的左右子树镜像反转，并获取翻转后该根节点的指针

TreeNode* invertTree(TreeNode* root) {

函数体.....

}

解的构成，

原问题的解总是由已经解决的左子问题和已经解决的右子问题调换一下就可以。

2）。递归的截止条件

截止条件就是能够得出结论的条件。

假设root不存在。即NULL，显然此时不用再反转，返回NULL就可以

3）总是反复的递归过程

当2）中全部的条件都“躲过了”，即root存在（当然左右子可能不存在）

我们就总是

先获取将root的左子树镜像翻转后的根节点，

再获取将root的右子树镜像翻转后的根节点，

交换两者，并返回root就可以。

TreeNode* newleft = invertTree(root->right);//先获取翻转后的左右子树的根节点

TreeNode* newright = invertTree(root->left);

root->left = newleft;//实现翻转

root->right = newright;

return root;//返回结果

4）控制反复的逻辑

以上已完毕

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
//将根节点反转，并获取翻转后该根节点的指针
     TreeNode* invertTree(TreeNode* root) {
        if(root == NULL){
             return NULL;
        }else{
            //这样做将：树的底层先被真正交换，然后其上一层才做反转
            TreeNode* newleft = invertTree(root->right);
            TreeNode* newright = invertTree(root->left);
            root->left = newleft;
            root->right = newright;
            return root;
        }
    }
};

事实上这个给定形式应该能猜測出，终于我们将二叉树反转后返回的肯定是根节点的指针，那么考虑用递归的话。每一次反转后返回的就是已经被反转后的子树的根节点，即先反转再返回那么直译就是后序式递归方法了，待我好好总结下这些该死的二叉树递归问题。

/************************************************多天后的华丽切割线********************************************************/

多天之后再来吊打此问题，用迭代法来做：

2。层序遍历。交换当前根节点的左右子树：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 //思路首先：用迭代来做
 //从上往下左右子树相互交换，层序（广度优先）遍历
class Solution {
public:
    void swapNode(TreeNode* root)
    {
        TreeNode* newleft=root->right;
        TreeNode* newright=root->left;
        root->left=newleft;
        root->right=newright;
    }
    TreeNode* invertTree(TreeNode* root) {
      if(root==NULL)
        return NULL;
      //广度优先遍历交换两个子树
      queue<TreeNode*> que;
      TreeNode* curNode=root;
      que.push(curNode);
      while (!que.empty())
      {
         curNode=que.front();//出队首元素
         que.pop();//删除队首元素
         swapNode(curNode);
         if(curNode->left!=NULL)
                que.push(curNode->left);
         if(curNode->right!=NULL)
                que.push(curNode->right);
      }
      return root;
    }
};

3，前序式深度优先搜索。

交换当前根节点的左右子树：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 //思路首先：用迭代来做
 //从上往下左右子树相互交换，利用前序式深度优先搜索
class Solution {
public:
    void swapNode(TreeNode* root)
    {
        TreeNode* newleft=root->right;
        TreeNode* newright=root->left;
        root->left=newleft;
        root->right=newright;
    }
    TreeNode* invertTree(TreeNode* root) {
      if(root==NULL)
        return NULL;
      //前序式深度优先搜索遍历交换两个子树
      stack<TreeNode*> stk;
      TreeNode* curNode=root;
      stk.push(curNode);
      while (!stk.empty())
      {
         curNode=stk.top();//出队首元素
         stk.pop();//删除队首元素
         swapNode(curNode);
         if(curNode->left!=NULL)
                stk.push(curNode->left);
         if(curNode->right!=NULL)
                stk.push(curNode->right);
      }
      return root;
    }
};

參考资源：

【1】递归法參考博文。地址为，http://www.cnblogs.com/ganganloveu/p/4640933.html

【2】迭代法參考自己的还有一篇博文：http://blog.csdn.net/ebowtang/article/details/50448037

注：本博文为EbowTang原创，兴许可能继续更新本文。假设转载，请务必复制本条信息！

原文地址：http://blog.csdn.net/ebowtang/article/details/50421096

原作者博客：http://blog.csdn.net/ebowtang

本博客LeetCode题解索引：http://blog.csdn.net/ebowtang/article/details/50668895