symmetric tree

symmetric_tree.cpp

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 * 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

 */
class Solution {
public:
    //recursive: left->left == right->right, && left->right == right->left
    //iterative: level order traversal; each level is symmetric, --> treu
    
    
    // Part 1: recurisve
    bool isSymmetric(TreeNode *root) {
        if (!root)
            return true;
        return isSymmetric (root->left, root->right);
    }
    
    bool isSymmetric (TreeNode *left, TreeNode *right) {
        if (!left && !right)
            return true;
        if (!left || !right)
            return false;
        
        if (left->val != right->val )
            return false;
        return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
    }
    
    
    // Part 2: iterat
    //iterative, levle order travel
    bool isSymmetric(TreeNode *root) {
        if (!root)
            return true;
        //return isSymmetric_recursive (root->left, root->right);
        
        //iterative, levle order travel
        vector<TreeNode *> oneLevel; 
        if (root->left)
            oneLevel.push_back(root->left);
        if (root->right) 
            oneLevel.push_back(root->right);
        
        while (!oneLevel.empty() ) {
            if ( !isSymmetric(oneLevel) )
                return false;
            
            //put to another level
            vector<TreeNode *> level2;
            for(int i=0; i<oneLevel.size(); i++) {
                TreeNode *aNode = oneLevel[i];
                if (!aNode)
                    continue;
                //if (aNode->left)
                    level2.push_back(aNode->left);
                //if (aNode->right)
                    level2.push_back(aNode->right);
            }
            oneLevel.clear();
            oneLevel = level2;
        }
        return true;
    }
    int numNodes( TreeNode *node) {
        if (!node)
            return 0;
        return (node->left != NULL) + (node->right != NULL);
    }
    int value(TreeNode *node) {
        if (!node)
            return INT_MIN;
        return node->val;
    }
    bool isSymmetric(vector<TreeNode *>& vNodes) {
        int size = vNodes.size();
        if (size % 2 != 0 )
            return false;
        int half = size/2;
        for(int i=0; i<half; i++)
            if (value(vNodes[i]) != value(vNodes[size-1-i] ) || numNodes(vNodes[i]) != numNodes(vNodes[size-1-i] ) )
                return false;
        return true;
    }
};