代码随想录二刷｜二叉树｜101. 对称二叉树

题目描述
解题思路 & 代码实现
- 递归法
- 迭代法
- - 使用队列
  - 使用栈

题目描述

101.对称二叉树

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：
在这里插入图片描述
输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：
在这里插入图片描述
输入：root = [1,2,2,null,3,null,3]
输出：false

提示：

树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

解题思路 & 代码实现

比较的是根节点的两颗子树是否对称，也就是说，左子树外侧的节点与右子树外侧的节点相等，同时，左子树内侧的节点与右子树内侧的节点相等。

因为我们要判断各个子节点是否相等，而这需要利用递归的返回值来判断，所以只能用后序遍历，准确来说，一个树要进行左右中，另一个树要进行右左中，这样才能同步进行判断。

递归法

递归三部曲：

确定递归函数的参数和返回值
因为要利用返回值来比较左右两个子树的节点是否相等，所以参数为左子树节点和右子树节点，返回值为bool
```
bool compare(TreeNode* left, TreeNode* right)
```
确定终止条件

当节点为空时，有如下几种情况：

- 左节点为空，右节点不为空。不对称，return false
- 左节点为空，右节点也为空。对称，return true
- 左节点不为空，右节点为空。不对称，return false

当节点不为空时：

- 左右都不为空，判断左右节点是否相同，不相同就return false，反之return true

if (left == NULL && right != NULL) return false;
else if (left != NULL && right == NULL) return false;
else if (left == NULL && right == NULL) return true;
else if (left->val != right->val) return true;

这里没有使用else，而是else if，因为我们把以上情况都排除之后，剩下的就是左右节点都不为空，且数值相同的情况。

确定递归的逻辑
单程递归的逻辑就是处理左右节点都不为空，且数值相同的情况。

比较二叉树外侧是否对称，传入的是左节点的左孩子，右节点的右孩子
比较二叉树内侧是否对称，传入的是左节点的右孩子，右节点的左孩子
左右都对称就返回true，有一侧不对称就返回false

bool outside = compare(left->left, right->right);
bool inside = compare(left->right, right->left);
bool isSam = outSide && inSide;
return isSam;

整体代码如下：

class Solution {
public:
	bool compare(TreeNode* left, TreeNode* right) {
		if (left == NULL && right != NULL) return false;
		else if (left != NULL && right == NULL) return false;
		else if (left == NULL && right == NULL) return true;
		else if (left->val != right->val) return true;

		bool outside = compare(left->left, right->right);
		bool inside = compare(left->right, right->left);
		bool isSam = outSide && inSide;
		
		return isSam;
	}
	
    bool isSymmetric(TreeNode* root) {
		if (root == NULL) return true;
		return compare(root->left, root->right);
    }
};

迭代法

使用队列

这里的迭代法可不是前中后序的迭代写法，因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。

这里我们可以使用队列来比较两个树（根节点的左右子树）是否相互翻转，（注意这不是层序遍历）

在遍历时把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
		if (root == NULL) return true;
		queue<TreeNode*> que;
		que.push(root->left);
		que.push(root->right);
		
		while (!que.empty()) {
			TreeNode* leftNode = que.front();
			que.pop();
			TreeNode* rightNode = que.front();
			que.pop();
			if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
				return false;
			}
			que.push(leftNode->left);
			que.push(rightNode->right);
			que.push(leftNode->right);
			que.push(rightNode->left);
		}
		return true;
    }
};

使用栈

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
		if (root == NULL) return true;
		stack<TreeNode*> st;
		st.push(root->left);
		st.push(root->right);
		
		while (!st.empty()) {
			TreeNode* leftNode = st.top();
			st.pop();
			TreeMode* rightNode = st.top()'
			st.pop();
			if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
				return false;
			}
			st.push(leftNode->left);
			st.push(rightNode->right);
			st.push(leftNode->right);
			st.push(rightNode->left);
		}
		return true;
    }
};