LeetCode - Symmetric Tree

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree is symmetric:

1
/ \
2   2
/ \ / \
3  4 4  3

But the following is not:

1
/ \
2   2
\   \
3    3

Note: Bonus points if you could solve it both recursively and iteratively.

http://oj.leetcode.com/problems/symmetric-tree/

Solution:

Recursive way is kind of like same tree. We can check if left subtree is mirror of right subtree, which is compare root1->left and root2->right, root1->right and root2->left.

Iterative way  is to check every level. Attention that inorder traversal is not correct in that input {1, 2, 3, 3, #, 2, #}. The result is {3, 2, 1, 2, 3} but obviously it is not a symmetric tree.

https://github.com/starcroce/leetcode/blob/master/symmetric_tree.cpp

// 28 ms for 190 cases
/**
* 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 isSymmetric(TreeNode *root) {
// IMPORTANT: Please reset any member data you declared, as
// the same Solution instance will be reused for each test case.
if(root == NULL) {
return true;
}
return isSym(root->left, root->right);
}

bool isSym(TreeNode *left, TreeNode *right) {
if(left == NULL && right == NULL) {
return true;
}
if(left == NULL || right == NULL) {
return false;
}
if(left->val != right->val) {
return false;
}
if(!isSym(left->right, right->left)) {
return false;
}
if(!isSym(left->left, right->right)) {
return false;
}
return true;
}
};

// 48 ms for 191 test cases
// iterative way, check every level
/**
* 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 isSymmetric(TreeNode *root) {
// IMPORTANT: Please reset any member data you declared, as
// the same Solution instance will be reused for each test case.
if(root == NULL) {
return true;
}
vector<TreeNode *> preLevel;
preLevel.push_back(root);
while(!preLevel.empty()) {
vector<TreeNode *> curLevel;
// push child node to curLevel
while(!preLevel.empty()) {
TreeNode *tmp = preLevel.back();
preLevel.pop_back();
if(tmp == NULL) {
continue;
}
curLevel.push_back(tmp->left);
curLevel.push_back(tmp->right);
}
int start = 0, end = curLevel.size() - 1;
// check the val in curLevel
while(start < end) {
TreeNode *leftNode = curLevel[start];
TreeNode *rightNode = curLevel[end];
int leftVal, rightVal;
if(leftNode == NULL) {
leftVal = -1;
}
else {
leftVal = leftNode->val;
}
if(rightNode == NULL) {
rightVal = -1;
}
else {
rightVal = rightNode->val;
}
if(leftVal != rightVal) {
return false;
}
start++;
end--;
}
// replace preLevel with curLevel
preLevel = curLevel;
}
return true;
}
};