Symmetric Tree [LeetCode]

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

Basic idea: Both recursive and iterative solutions. 

Iterative solution:

/**
 * 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) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(root == NULL) 
            return true;
        
        vector<TreeNode*> layer;
        layer.push_back(root);
        while(true) {
            //determine if the tree is symetric
            for(int i = 0; i < layer.size()/2; i ++ ) {
                //layer[i] compare layer[layer.size() - 1 - i]
                int right_idx = layer.size() - 1 - i;
                if((layer[i]->left == NULL && layer[right_idx]->right == NULL ||
                    (layer[i]->left != NULL && layer[right_idx]->right != NULL &&
                    layer[i]->left->val == layer[right_idx]->right->val)) && 
                    (layer[i]->right == NULL && layer[right_idx]->left == NULL ||
                     (layer[i]->right != NULL && layer[right_idx]->left != NULL && 
                     layer[i]->right->val == layer[right_idx]->left->val)))
                    continue;
                else
                    return false;
            }
            
            if(layer.size() % 2 != 0) {
                int middle = layer.size() / 2;
                if(layer[middle]->left == NULL && layer[middle]->right == NULL ||
                    (layer[middle]->left != NULL && layer[middle]->right != NULL && 
                    layer[middle]->left->val == layer[middle]->right->val)){
                        //do nothing
                    }else{
                        return false;
                    }
            }
            
            //get node for next layer
            vector<TreeNode*> new_layer;
            for(auto node : layer) {
                if(node->left != NULL)
                    new_layer.push_back(node->left);
                if(node->right != NULL)
                    new_layer.push_back(node->right);
            }
            if(new_layer.size() == 0)
                break;
                
            layer = new_layer;
        }
        
        return true;
    }
};

Recursive solution: easier to understand.

class Solution {
public:
    bool isSubSymmetric(TreeNode * left, TreeNode * right) {
        if(left == NULL && right == NULL)
            return true;
        else if(left != NULL && right == NULL || (right != NULL && left == NULL))
            return false;
        else if(left->val != right->val)
            return false;
        else
            return isSubSymmetric(left->left, right->right) && isSubSymmetric(left->right, right->left);
    }
    bool isSymmetric(TreeNode *root) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(root == NULL) 
            return true;
        
        return isSubSymmetric(root->left, root->right);
    }
};