[LeetCode] 226. 翻转二叉树

[LeetCode] 226. 翻转二叉树

方法一：递归

思路与算法：

其实就是交换一下左右节点，然后再递归的交换左节点，右节点
根据动画图我们可以总结出递归的两个条件如下：

• 终止条件：当前节点为 null 时返回
• 交换当前节点的左右节点，再递归的交换当前节点的左节点，递归的交换当前节点的右节点

C++解法：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==NULL) return root;
        TreeNode* tmp = root->left;
        root->left = root->right;
        root->right = tmp;
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

Python3 解法：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
    	# 自顶而下
        # def coulation(root):
        #     if not root:
        #         return 
        #     root.left, root.right = root.right, root.left
        #     coulation(root.left)
        #     coulation(root.right)
        # coulation(root)
        # return root
        /*自底向上*/
        if not root:
            return 
        root.left ,root.right = self.invertTree(root.right),self.invertTree(root.left)
        return root

复杂度分析

• 时间复杂度：$O(N^2)$，其中 N为二叉树节点的数目。我们会遍历二叉树中的每一个节点，对每个节点而言，我们在常数时间内交换其两棵子树。
• 空间复杂度：$O(N)$。使用的空间由递归栈的深度决定，它等于当前节点在二叉树中的高度。在平均情况下，二叉树的高度与节点个数为对数关系，即 $O(\log N)$。而在最坏情况下，树形成链状，空间复杂度为 $O(\log N)$。

方法二：迭代

递归实现也就是深度优先遍历的方式，那么对应的就是广度优先遍历。
广度优先遍历需要额外的数据结构–队列，来存放临时遍历到的元素。
深度优先遍历的特点是一竿子插到底，不行了再退回来继续；而广度优先遍历的特点是层层扫荡。
所以，我们需要先将根节点放入到队列中，然后不断的迭代队列中的元素。
对当前元素调换其左右子树的位置，然后：

• 判断其左子树是否为空，不为空就放入队列中
• 判断其右子树是否为空，不为空就放入队列中

动态图如下：

深度优先遍历和广度优先遍历，从动画图中看起来很类似，这是因为演示的树层数只有三层。
时间复杂度：同样每个节点都需要入队列/出队列一次，所以是 $O(n)$。
空间复杂度：最坏的情况下会包含所有的叶子节点，完全二叉树叶子节点是 $n/2$个，所以时间复杂度是 $0(n)$。

C++解法：

    TreeNode* invertTree(TreeNode* root) {
        if (!root) return root;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            auto p = q.front();
            q.pop();
            swap(p->left, p->right);
            if (p->left) q.push(p->left);
            if (p->right) q.push(p->right);
        }
        return root;
    }

Python解法：

class Solution(object):
	def invertTree(self, root):
		"""
		:type root: TreeNode
		:rtype: TreeNode
		"""
		if not root:
			return None
		# 将二叉树中的节点逐层放入队列中，再迭代处理队列中的元素
		queue = [root]
		while queue:
			# 每次都从队列中拿一个节点，并交换这个节点的左右子树
			tmp = queue.pop(0)
			tmp.left,tmp.right = tmp.right,tmp.left
			# 如果当前节点的左子树不为空，则放入队列等待后续处理
			if tmp.left:
				queue.append(tmp.left)
			# 如果当前节点的右子树不为空，则放入队列等待后续处理	
			if tmp.right:
				queue.append(tmp.right)
		# 返回处理完的根节点
		return root