对称二叉树 给定一个二叉树，检查它是否是镜像对称的（递归和迭代两种解法）。

力扣（LeetCode）对应链接

对称二叉树

给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

二叉树的定义：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

递归解法

两个结点是镜像对称的需要满足以下两个条件：

1. 结点上的值相等
2. 其中结点a的左儿子的值等于结点b的右儿子的值，结点a的右儿子的值等于结点b的左儿子的值。

因此，可以根据这两个条件写出递归算法
首先，我们自定义一个判断两个结点是否镜像对称的函数，实现代码如下：

bool sub_isSymmetric(TreeNode * root1, TreeNode * root2) {
		if(root1==NULL&&root2==NULL)
			return true;
		else if(root1==NULL&&root2!=NULL)
			return false;
		else if(root1!=NULL&&root2==NULL)
			return false;
		else
			return (root1->val==root2->val)&&sub_isSymmetric(root1->left,root2->right)&&sub_isSymmetric(root1->right,root2->left);
}

然后我们要做的事情很简单，只需要把根结点的左右儿子放进去

bool isSymmetric(TreeNode* root) {
	if(root==NULL)
		return true;
	else
		return sub_isSymmetric(root->left,root->right);
}

完整的通过代码：

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

bool isSymmetric(TreeNode* root) {
	if(root==NULL)
		return true;
	else
		return sub_isSymmetric(root->left,root->right);
}
};

迭代算法

大致思路：

1. 利用二叉树的层次遍历获得二叉树每一层的数据（如何通过层次遍历获得二叉树每一层的数据对应链接）
2. 判断依据：通过判断每一次的数据是否镜像对称
3. 重点&难点：二叉树 [1,2,2,null,3,null,3] 不是镜像对称的，而二叉树 [1,2,2,null,3,3,null] 是镜像对称的，然而，如果按照步骤一中的方法两棵不同的二叉树得到的每一层的数据是一样的，如何区分出这两棵二叉树？
4. 解决方案：在将每一层的信息存入二维向量时，将NULL也存入，读取数据时，若为NULL，则对应的数据不是空，而是一个标识（例如-1，0等等），这样就能区分出步骤3中的两棵不同的树

算法实现代码：

bool isSymmetric(TreeNode* root) {
	vector<vector<int>> ans;

	queue<TreeNode*> q;

	TreeNode* p = root;
	if (p == NULL)
		return true;
	else
		q.push(p);

	while (!q.empty())
	{
		vector<int> tmp;
		int size = q.size();
		for (int i = 0; i < size; i++)
		{
			p = q.front();
			q.pop();
			if (p != NULL)
				tmp.push_back(p->val);
			else
				tmp.push_back(-1);
			if (p != NULL)
			{
				if (p->left != NULL)
					q.push(p->left);
				else
					q.push(NULL);
				if (p->right != NULL)
					q.push(p->right);
				else
					q.push(NULL);
			}
			
		}
		ans.push_back(tmp);
	}

	for (int i = 0; i < ans.size(); i++)
	{
		for (int j = 0; j < ans[i].size() / 2; j++)
		{
			if (ans[i][j] != ans[i][ans[i].size() - j-1])
				return false;
		}
	}
	return true;
}

完整测试代码

#include<iostream>
#include<queue>
using namespace std;

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

bool isSymmetric(TreeNode* root) {
	vector<vector<int>> ans;

	queue<TreeNode*> q;

	TreeNode* p = root;
	if (p == NULL)
		return true;
	else
		q.push(p);

	while (!q.empty())
	{
		vector<int> tmp;
		int size = q.size();
		for (int i = 0; i < size; i++)
		{
			p = q.front();
			q.pop();
			if (p != NULL)
				tmp.push_back(p->val);
			else
				tmp.push_back(-1);
			if (p != NULL)
			{
				if (p->left != NULL)
					q.push(p->left);
				else
					q.push(NULL);
				if (p->right != NULL)
					q.push(p->right);
				else
					q.push(NULL);
			}
			
		}
		ans.push_back(tmp);
	}

	for (int i = 0; i < ans.size(); i++)
	{
		for (int j = 0; j < ans[i].size() / 2; j++)
		{
			if (ans[i][j] != ans[i][ans[i].size() - j-1])
				return false;
		}
	}
	return true;
}

int main()
{
	TreeNode t1(1);
	TreeNode t2(2);
	TreeNode t3(2);
	TreeNode t4(3);
	TreeNode t5(3);
	t1.left = &t2;
	t1.right = &t3;
	t2.right = &t5;
	t3.right = &t4;
	TreeNode* t = &t1;
	cout << isSymmetric(t);
	return 0;
}

用的是测试上面给出的第二个案例：

测试结果：

最后代码也能通过LeetCode的oj
LeetCode通过代码：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
	vector<vector<int>> ans;

	queue<TreeNode*> q;

	TreeNode* p = root;
	if (p == NULL)
		return true;
	else
		q.push(p);

	while (!q.empty())
	{
		vector<int> tmp;
		int size = q.size();
		for (int i = 0; i < size; i++)
		{
			p = q.front();
			q.pop();
			if (p != NULL)
				tmp.push_back(p->val);
			else
				tmp.push_back(-1);
			if (p != NULL)
			{
				if (p->left != NULL)
					q.push(p->left);
				else
					q.push(NULL);
				if (p->right != NULL)
					q.push(p->right);
				else
					q.push(NULL);
			}
			
		}
		ans.push_back(tmp);
	}

	for (int i = 0; i < ans.size(); i++)
	{
		for (int j = 0; j < ans[i].size() / 2; j++)
		{
			if (ans[i][j] != ans[i][ans[i].size() - j-1])
				return false;
		}
	}
	return true;
}
};