LeetCode Symmetric Tree

class Solution {
public:
    bool isSymmetric(TreeNode *root) {
        if (root == NULL) return true;
        return dfs(root->left, root->right);
    }
    
    bool dfs(TreeNode* curnode, TreeNode* symnode) {
        if (curnode == NULL && symnode == NULL) return true;
        if (curnode != NULL && symnode != NULL && curnode->val == symnode->val) {
            return dfs(curnode->left, symnode->right) && dfs(curnode->right, symnode->left);
        }
        return false;
    }
    
    bool _isSymmetric(TreeNode *root) {
        if (root == NULL) return true;
        vector<TreeNode*> sa;
        vector<TreeNode*> sb;
        sa.push_back(root->left);
        sb.push_back(root->right);

        while (!sa.empty() && !sb.empty()) {
            TreeNode* anode = sa.back();
            TreeNode* bnode = sb.back();

            sa.pop_back();
            sb.pop_back();
            
            if (anode == NULL && bnode == NULL) {
                continue;
            }
            
            if (anode != NULL && bnode != NULL && anode->val == bnode->val) {
                sa.push_back(anode->left);
                sb.push_back(bnode->right);

                sa.push_back(anode->right);
                sb.push_back(bnode->left);
            } else {
                return false;
            }
        }
        if (sa.size() != sb.size()) return false;
        return true;
    }
};

同时对左右子树进行遍历，只不过因为是对称的所以遍历时节点顺序要交换一下。如果是对称的，那么遍历节点应该一一对应，如果中间出现不一致则不对称。

第二轮：

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
只回忆起递归版本

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