leetcode Symmetric Tree

这里是给定一个数，判断是不是对称的，即根据根画一竖直线对折重合一样。

For example, this binary tree is symmetric:

    1
   / 
  2   2
 /  / 
3  4 4  3

But the following is not:

    1
   / 
  2   2
      
   3    3

Note:Bonus points if you could solve it both recursively and iteratively.

这题标注是easy的题。但是试了好多次才想通。

错误的尝试一：以为是中序遍历一下，然后矩阵对称相等就行，实际是不行的，例如把上面第二个图中，右边的3和2调换位置，他的中序遍历结果是根据中心对称，但实际不是对称的。

错误的尝试二：以为对左子树中序遍历，对右子树反向中序遍历（右根左），如果两者一样就是对称。就如上面第二例子就bug了

然后静下心，好好想，既然标注easy，应该不那么复杂。终于被我想到了用递归的方法。其实不难，就是判断两个子树一个数的右边是不是等于另一个树的左边，依次类推。和上一题差不多。

/**
 * 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 isSym(TreeNode *p, TreeNode *q)
{
    if (!p) return !q;
    if (!q) return !p;
    if (p -> val != q -> val)
        return false;
    bool flag = isSym(p -> left, q -> right);
    return flag && isSym(p -> right, q -> left);
}

    bool isSymmetric(TreeNode *root) 
    {
        if (!root) return true;
        if (!root -> left) return !root->right;
        if (!root -> right) return !root->left;
        
        return isSym(root->left, root->right);
    }
};

 如果不用递归，用迭代的话。其实我上面的第一次的错误尝试是有点道理的，只要遍历的时候左右相反的同步即可。当然最后要判断lf和ri是否为空以及栈是否都为空。

class Solution {
public:
    bool isSymmetric(TreeNode *root) 
    {
        if (!root) return true;
        if (!root -> left) return !root -> right;
        if (!root -> right) return !root ->left;
        
        stack<TreeNode *> sta1, sta2;
        TreeNode *lf = root -> left, *ri  = root -> right;
        
        while ((lf && ri) || (!sta1.empty() && !sta2.empty()))
        {
            while (lf && ri)
            {
                sta1.push(lf);
                sta2.push(ri);
                lf = lf -> left;
                ri = ri -> right;
            }
            if ((lf && !ri) || (ri && !lf)) return false;
            if (!sta1.empty() && !sta2.empty())
            {
                lf = sta1.top();
                ri = sta2.top();
                sta1.pop();
                sta2.pop();
                if (lf -> val != ri -> val)
                    return false;
                lf = lf -> right;
                ri = ri -> left;
            }
        }
        if ((lf && !ri) || (ri && !lf)) return false;
        if (!sta1.empty() || !sta2.empty()) return false;
        return true;
    }
};