[leetcode] Symmetric Tree

Symmetric Tree

recursion

/**
 * 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 isSymmetricTool(TreeNode *left,TreeNode *right){
        if(left==NULL&&right==NULL){
            return true;
        }
        if(left!=NULL&&right!=NULL&&left->val==right->val){//recursion
            return isSymmetricTool(left->right,right->left)&&isSymmetricTool(left->left,right->right);
        }
        return false;
    }
    bool isSymmetric(TreeNode *root) {
        if(root==NULL){
            return true;
        }else{
            return isSymmetricTool(root->left,root->right);
        }
    }
};

iteration,using queue

/**
 * 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) {
        if(root==NULL){
            return true;
        }
        queue<TreeNode*> ltree,rtree;
        if(root->left){
            ltree.push(root->left);
        }
        if(root->right){
            rtree.push(root->right);
        }
        
        TreeNode *lp,*rp;
        while(!ltree.empty()&&!rtree.empty()){
            lp=ltree.front();
            ltree.pop();
            rp=rtree.front();
            rtree.pop();

            if(lp==NULL&&rp==NULL){
                continue;
            }
            if(lp==NULL||rp==NULL){
                return false;
            }
            if(lp->val!=rp->val){
                return false;
            }
            ltree.push(lp->left);
            ltree.push(lp->right);
            rtree.push(rp->right);
            rtree.push(rp->left);
        }
        
        if(ltree.empty()&&rtree.empty()){
            return true;
        }else{
            return false;
        }
        
    }
};