226. Invert Binary Tree
Total Accepted: 57653
Total Submissions: 136144
Difficulty: Easy
Invert a binary tree.
4 / \ 2 7 / \ / \ 1 3 6 9to
4 / \ 7 2 / \ / \ 9 6 3 1Trivia:
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.
Subscribe to see which companies asked this question
/**
* 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;
}
}
};
其实这个给定形式应该能推测出，最终我们将二叉树反转后返回的肯定是根节点的指针，那么考虑用递归的话，每一次反转后返回的就是已经被反转后的子树的根节点，即先反转再返回那么直译就是后序式递归方法了，待我好好总结下这些该死的二叉树递归问题。
/************************************************华丽的分割线********************************************************/
多天之后再来吊打此问题，用迭代法来做：
广度优先搜索时，交换当前根节点的左右子树：
/**
* 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;
}
};
前序式深度优先搜索时，交换当前根节点的左右子树：
/**
* 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;
}
};
注：本博文为EbowTang原创，后续可能继续更新本文。如果转载，请务必复制本条信息！
原文地址：http://blog.csdn.net/ebowtang/article/details/50421096
原作者博客：http://blog.csdn.net/ebowtang
参考资源：
【1】递归法参考博文，地址为，http://www.cnblogs.com/ganganloveu/p/4640933.html
【2】迭代法参考自己的另一篇博文：http://blog.csdn.net/ebowtang/article/details/50448037