LeetCode226. 翻转二叉树

LeetCode题目链接：https://leetcode.cn/problems/invert-binary-tree/

题目叙述：

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

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

输入：root = [2,1,3]

输出：[2,3,1]

示例 3：

输入：root = []

输出：[]

思路

这道题其实我们只需要反转每个节点左子树和右子树就可以了，可以采用递归法和迭代法，在下面我都会讲解，递归法就是我们对一个问题，将它抽象为有限个子问题，然后用同样的方法去处理这些子问题就行了

我们不要去想递归的过程，只需要处理好递归的边界和处理条件，这样我们写出来的递归就肯定是对的.

处理递归，核心就是千万不要想子问题的过程，你脑子能处理几层？马上就绕迷糊了。要想子问题的结果，思路就清晰了

只要代码的边界条件和非边界条件的逻辑写对了，其他的事情交给数学归纳法就好了。也就是说，写对了这两个逻辑，你的代码自动就是正确的了，没必要想递归是怎么一层一层走的。

思路延申到所有二叉树的题目

1. 如何思考二叉树相关问题？

• 不要一开始就陷入细节，而是思考整棵树与其左右子树的关系。

2. 为什么需要使用递归？

• 子问题和原问题是相似的，他们执行的代码也是相同的（类比循环），但是子问题需要把计算结果返回给上一级，这更适合用递归实现。

3. 为什么这样写就一定能算出正确答案？

• 由于子问题的规模比原问题小，不断"递"下去，总会有个尽头，即递归的边界条件 ( base case )，直接返回它的答案"归"；
• 类似于数学归纳法（多米诺骨牌），n=1时类似边界条件；n=m时类似往后任意一个节点

4. 计算机是怎么执行递归的？

• 当程序执行"递"动作时，计算机使用栈保存这个发出"递"动作的对象，程序不断"递"，计算机不断压栈，直到边界时，程序发生"归"动作，正好将执行的答案"归"给栈顶元素，随后程序不断"归"，计算机不断出栈，直到返回原问题的答案，栈空。

5. 另一种递归思路

• 维护全局变量，使用二叉树遍历函数，不断更新全局变量最大值。

递归法

递归法使用前序遍历和后序遍历都是可以的，但是使用中序遍历就得注意了，因为中序遍历的话，你处理的节点顺序是左中右，就证明你先处理过左子树，左子树已经反转过一次了，如果此时翻转右子树，就是

对原来的左子树又进行了一次翻转，所以这点我们得注意！

前序遍历

//前序遍历翻转二叉树
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;
		invertTree(root->left);
		invertTree(root->right);
		swap(root->left, root->right);
		return root;
	}
};

中序遍历

//中序遍历翻转二叉树
class Solution {
public:
	TreeNode* invertTree(TreeNode* root) {
		if (root == NULL) return root;
		//翻转左子树
		invertTree(root->left);
		swap(root->left, root->right);
		//注意这里！因为前面已经翻转过一次左子树了，那么这里我们要对原来的左子树进行翻转，就还是要操作"左子树"
		invertTree(root->left);
		return root;
	}
};

迭代法

迭代法我们使用前序，后序，层序遍历都是可以的，在下面我会介绍三种方法：

前序遍历

//前序遍历迭代法翻转二叉树

class Solution {
public:
	TreeNode* invertTree(TreeNode* root) {
		if (root == NULL) return root;
		stack<TreeNode*> st;
		st.push(root);
		while (!st.empty()) {
			TreeNode* current = st.top();
			st.pop();
			swap(current->left, current->right);
			if (current->right != NULL) st.push(current->right);
			if (current->left != NULL) st.push(current->left);
		}
		return root;
	}
};

层序遍历：

//层序遍历迭代法翻转二叉树
class Solution {
public:
	TreeNode* invertTree(TreeNode* root) {
		if (root == NULL) return root;
		queue<TreeNode*> que;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			while (size--) {
				TreeNode* current = que.front();
				que.pop();
				swap(current->left, current->right);
				if (current->left != NULL) que.push(current->left);
				if (current->right != NULL) que.push(current->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* current = st.top();
   		st.pop();
   		swap(current->left, current->right);
   		//与前序遍历唯一的区别就是先处理左子树，其实这不叫后序遍历，实际的遍历顺序是中右左！
   		if (current->left != NULL) st.push(current->left);
   		if (current->right != NULL) st.push(current->right);
   	}
   	return root;
   }
};