LeetCode 剑指 Offer 28. 对称的二叉树

原题链接
一道思路比较清晰的题目。
关于树的处理，第一想到的就是递归咯。
思路：

1. 想要比较左右是否对称，遍历。
2. 一般的中序遍历是从左子节点到根节点再到右子节点，根据这个，我们对称地，先遍历右子节点，再遍历根节点，最后遍历左子节点。
3. 得到两个遍历数组，然后比较这两个数组中的结果。
4. 时间复杂度是O(n)，空间复杂度为O(n).

给出代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> vec;
    vector<int> vec2;
    int mapFromLeft(TreeNode* root){
        if(!root) return -1;
        vec.emplace_back(mapFromLeft(root->left));
        vec.emplace_back(root->val);
        vec.emplace_back(mapFromLeft(root->right));
        return root->val;
    }

    int mapFromRight(TreeNode* root){
        if(!root) return -1;
        vec2.emplace_back(mapFromRight(root->right));
        vec2.emplace_back(root->val);
        vec2.emplace_back(mapFromRight(root->left));
        return root->val;
    }
    
    bool isSymmetric(TreeNode* root) {
        mapFromLeft(root);
        mapFromRight(root);
        for(int i = 0; i<vec.size(); i++){
            if(vec[i] != vec2[i]) return false;
        }
        return true;
    }
};

这种方法思路很清晰，递归结构一目了然，但是代码的简洁性不够高。同样地使用递归结构，就地比较数组元素的关系，能够优化。

class Solution {
public:
    bool dualRoot(TreeNode* root1, TreeNode* root2){
        if(!root1 && !root2 )return true;
        if((root1 && !root2) || (root2 && !root1))return false;
        if(root1->val == root2->val) return dualRoot(root1->left,root2->right) && dualRoot(root1->right,root2->left);
        return false;
    }

    bool isSymmetric(TreeNode* root) {
        TreeNode* root1;
        TreeNode* root2;
        root1 = root2 = root;
        return dualRoot(root1,root2);
    }
};

思路采纳