<LeetCode OJ> 226. Invert Binary Tree-CSDN博客

226. Invert Binary Tree

Total Accepted: 57653 Total Submissions: 136144 Difficulty: Easy

Invert a binary tree.

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

     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