struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
//both recursive solution and iterative solution here
//iterative one we can use BFS thought, but with two BFS route, and the order to push the child in queue
//should be adjusted accordingly
public:
bool Recursive(TreeNode* a, TreeNode* b)
{
if(!a && !b)
return true;
if(!a || !b)
return false;
if(a->val != b->val)
return false;
return Recursive(a->left, b->right)&&Recursive(a->right, b->left);
}
bool Iterative(TreeNode* root)
{
queue<TreeNode*> left, right;
left.push(root->left); right.push(root->right);
while (!left.empty() && !right.empty())
{
TreeNode* curLeft = left.front(); TreeNode* curRight = right.front();
left.pop(); right.pop();
if(!curLeft && !curRight)
continue;
if(!curLeft || !curRight)
return false;
if(curLeft->val != curRight->val)
return false;
left.push(curLeft->left); left.push(curLeft->right);
right.push(curRight->right); right.push(curRight->left);
}
return true;
}
bool isSymmetric(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(!root)
return true;
//return Recursive(root->left, root->right);
return Iterative(root);
}
};
second time
/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSymmetricUtil(TreeNode* root1, TreeNode* root2)
{
if(root1 == NULL && root2 == NULL) return true;
if(root1 == NULL && root2 != NULL) return false;
if(root1 != NULL && root2 == NULL) return false;
return root1->val == root2->val && isSymmetricUtil(root1->left, root2->right) && isSymmetricUtil(root1->right, root2->left);
}
bool isSymmetric(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(root == NULL) return true;
return isSymmetricUtil(root->left, root->right);
}
};