力扣刷题笔记15—— 对称的二叉树

问题

来自力扣：

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

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

    1
   / \
  2   2
   \   \
   3    3


示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：

我的代码

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>
#include<queue>
#include <typeinfo>
 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };
 
 class Solution {
 public:
	 bool isSymmetric(TreeNode* root) {
		 if (root == NULL) return true;
		 TreeNode* ml = mirrorTree(root->left);//求镜像
		 return (isSubStructure(ml, root->right) && isSubStructure(root->right, ml));


	 }
	 //镜像
	 TreeNode* mirrorTree(TreeNode* root) {
		 if (root == NULL) return NULL;
		 TreeNode* tmp = root->left;
		 root->left = mirrorNode(root->right);
		 root->right = mirrorNode(tmp);
		 return root;
	 }
	 //镜像的递归函数
	 TreeNode* mirrorNode(TreeNode* node) {
		 if (node == NULL) return NULL;
		 TreeNode* tmp = node->left;
		 node->left = mirrorNode(node->right);
		 node->right = mirrorNode(tmp);
		 return node;
	 }
	 //子结构
	 bool isSubStructure(TreeNode* A, TreeNode* B) {
		 queue <TreeNode> qnode;
		 if (A == NULL && B == NULL) return true;//当二叉树只有头结点时，也是对称的。
		 if (A == NULL || B == NULL) return false;
		 qnode.push(*A);
		 while (!qnode.empty()) {
			 if (issubstructure(qnode.front(), *B)) return true;
			 if (qnode.front().left != NULL)
				 qnode.push(*(qnode.front().left));
			 if (qnode.front().right != NULL)
				 qnode.push(*(qnode.front().right));
			 qnode.pop();

		 }
		 return false;
	 }
	 //子结构的递归函数
	 bool issubstructure(TreeNode A, TreeNode B) {
		 if (B.val == A.val) {
			 if (B.left == NULL || (A.left != NULL && issubstructure(*(A.left), *(B.left)))) {
				 if (B.right == NULL || (A.right != NULL && issubstructure(*(A.right), *(B.right)))) {
					 return true;
				 }
			 }
		 }
		 return false;
	 }
	 //用于测试的函数，笔记11的那个打印函数
	 vector<int> levelOrder(TreeNode* root) {
		 vector<int> vecNode;
		 queue <TreeNode> qnode;
		 if (root != NULL)
			 qnode.push(*root);
		 while (!qnode.empty()) {
			 vecNode.push_back(qnode.front().val);
			 if (qnode.front().left != NULL)
				 qnode.push(*(qnode.front().left));
			 if (qnode.front().right != NULL)
				 qnode.push(*(qnode.front().right));
			 qnode.pop();
		 }
		 return vecNode;
	 }
 };

int main() {
	TreeNode* root=NULL;
	root = new TreeNode(3);
	root->left = new TreeNode(4);
	root->right = new TreeNode(4);
	root->left->left = new TreeNode(1);
	root->left->right = new TreeNode(2);
	root->right->left = new TreeNode(2);
	root->right->right = new TreeNode(2);
	TreeNode* root2 = NULL;
	Solution mysolution;
	bool s = mysolution.isSymmetric(root);
	bool s2 = mysolution.isSymmetric(root2);
	cout << s<<"\t"<<s2;
	return 0;
}

我本来想重新写一个递归的，但是一时想不出来，然后发现用笔记14的镜像和笔记13的子结构也可以实现，就偷懒了。
注意1：虽然可以用镜像，但是得注意，二叉树求镜像是没有拷贝一份的，而是在原二叉树上求的，所以我是在左分支求的镜像。
注意2：在isSubStructure中多加了一句代码。

示例代码

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)return true;
        if(root->left==NULL&&root->right==NULL)return true;
        if(root->left==NULL&&root->right!=NULL)return false;
        if(root->left!=NULL&&root->right==NULL)return false;
        if(mir(root->left,root->right))return true;
        return false;
    }
    int mir(TreeNode* A,TreeNode* B){
        // if(A==NULL&&B==NULL)return 1;
        // if(A==NULL&&B!=NULL)return 0;
        // if(A!=NULL&&B==NULL)return 0;
        if(A->val!=B->val)return 0;
        if(A->left==NULL&&B->left==NULL&&A->right==NULL&&B->right==NULL)return 1;

        else if(A->left==NULL&&B->right!=NULL||A->left!=NULL&&B->right==NULL)return 0;

        else if(A->right==NULL&&B->left!=NULL||A->right!=NULL&&B->left==NULL)return  0;
        if(A->left!=NULL&&B->right!=NULL){
            if(!mir(A->left,B->right))return 0;
        }
        if(A->right!=NULL&&B->left!=NULL){
            if(!mir(A->right,B->left))return 0;
        }
        return 1;
    }

};

示例代码是用递归实现的，确实比我的简单了很多。