非递归解法

/**
 * 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) {
       stack <TreeNode*> stackLeft;
       stack <TreeNode*> stackRight;
       
       if(root == NULL ||(root && (!root->left) && (!root->right))){
           return true;
       }
       
       if((root->left && (!root->right))||(!root->left && root->right)){
           return false;
       }
       TreeNode *pLeft = root->left;
       TreeNode *pRight = root->right;
       while((pLeft||(!stackLeft.empty())) && (pRight ||(!stackRight.empty()))){
            while(pLeft && pRight){
               
                if(pLeft->val != pRight->val){
                    return false;
                }
                stackLeft.push(pLeft); 
                pLeft = pLeft->left;
                stackRight.push(pRight);
                pRight = pRight->right;
            }
            
            if(pLeft || pRight){
                return false;
            }
            
            pLeft = stackLeft.top();
            stackLeft.pop();
            pLeft = pLeft->right;
            
            pRight = stackRight.top();
            stackRight.pop();
            pRight = pRight->left;
       }
       
       if( (pLeft||(!stackLeft.empty())) || (pRight ||(!stackRight.empty()))){
           return false;
       }
       
       return true;
    }
};</span>

递归解法

leetCode Symmetric Tree