LeetCode题目链接:

题目叙述:

给你一棵二叉树的根节点 root ,翻转这棵二叉树,并返回其根节点。
LeetCode226. 翻转二叉树-LMLPHP

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

示例 2:
LeetCode226. 翻转二叉树-LMLPHP
输入:root = [2,1,3]
输出:[2,3,1]

示例 3:
输入:root = []
输出:[]

思路

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

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

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

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

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

  1. 如何思考二叉树相关问题?
  • 不要一开始就陷入细节,而是思考整棵树与其左右子树的关系。
  1. 为什么需要使用递归?
  • 子问题和原问题是相似的,他们执行的代码也是相同的(类比循环),但是子问题需要把计算结果返回给上一级,这更适合用递归实现。
  1. 为什么这样写就一定能算出正确答案?
  • 由于子问题的规模比原问题小,不断“递”下去,总会有个尽头,即递归的边界条件 ( base case ),直接返回它的答案“归”;
  • 类似于数学归纳法(多米诺骨牌),n=1时类似边界条件;n=m时类似往后任意一个节点
  1. 计算机是怎么执行递归的?
  • 当程序执行“递”动作时,计算机使用栈保存这个发出“递”动作的对象,程序不断“递”,计算机不断压栈,直到边界时,程序发生“归”动作,正好将执行的答案“归”给栈顶元素,随后程序不断“归”,计算机不断出栈,直到返回原问题的答案,栈空。
  1. 另一种递归思路
  • 维护全局变量,使用二叉树遍历函数,不断更新全局变量最大值。

递归法

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

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

前序遍历

//前序遍历翻转二叉树
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;
   }
};


07-24 15:37