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 = ; i < layer.size()/; i ++ ) {
                 //layer[i] compare layer[layer.size() - 1 - i]
                 int right_idx = layer.size() -  - 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() %  != ) {
                 int middle = layer.size() / ;
                 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() == )
                 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);
     }
 };