[Leetcode] Symmetric tree 对称二叉树

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

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

confused what"{1,#,2,3}"means? >read more on how binary tree is serialized on OJ.

OJ's Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

   1
  / 
 2   3
    /
   4
    
     5

The above binary tree is serialized as"{1,2,3,#,#,4,#,#,5}".

题意：对称指的是二叉树的结构上的对称。不是说某一层以上都是对称的，该层只有两个元素，分别对应上一层对称元素的两右孩子，这也是对称。这种情况的结构上不对称。如题中的反例。

方法一：维护两个队列，层次遍历，一个从左到右，一个从右到左，比较队首借点。思路上有点像判断两二叉树是否相同那题

 

/**
 * 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==nullptr)   
            return true;

        queue<TreeNode *> Q1;
        queue<TreeNode *> Q2;

        Q1.push(root->left); 
        Q2.push(root->right);

        while( !Q1.empty())
        {
            TreeNode *node1=Q1.front();
            TreeNode *node2=Q2.front();

            Q1.pop();
            Q2.pop();

            if(node1==nullptr&&node2==nullptr)
                continue;
            if(node1==nullptr||node2==nullptr)
                return false;
            if(node1->val !=node2->val)
                return false;
                
            Q1.push(node1->left);
            Q1.push(node1->right);
            Q2.push(node2->right);
            Q2.push(node2->left);
            
        }   
        return true;
    }
};

/*  //主体的另一种写法

while (!q1.empty() && !q2.empty())

{
   TreeNode *node1 = q1.front();
　　TreeNode *node2 = q2.front();
　　q1.pop();
　　q2.pop();
　　if((node1 && !node2) || (!node1 && node2)) return false;
　　if (node1)

　　{
　　　　if (node1->val != node2->val) return false;
　　　　q1.push(node1->left);
　　　　q1.push(node1->right);
　　　　q2.push(node2->right);
　　　　q2.push(node2->left);
　　}

}

*/

方法二：使用栈。特别值得注意的是：入栈的顺序，先左左，后右右，交替入栈，这样，出栈时才能保证同时从一层的两头向中间遍历。循环中，注意的条件：左右同时为0时，这种情况重新遍历即可；有一者为0，则说明不对称，返回false；对应的值不相等，也是返回false；到叶节点以后也是重新遍历未访问的结点即可。

/**
 * 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||(root->left==NULL&&root->right==NULL))
            return true;

        stack<TreeNode *> stk;
        stk.push(root->left);
        stk.push(root->right);

        while( !stk.empty())
        {
            TreeNode *rNode=stk.top();
            stk.pop();
            TreeNode *lNode=stk.top();
            stk.pop();

            if(rNode==NULL&&lNode=NULL)
                continue;
            if(rNode==NULL||lNode==NULL)
                return false;
            if(rNode->val !=lNode->val)
                return false;
            
            //判断是否到叶节点，若是返回遍历其他
            if(lNode->left==NULL&&lNode->right==NULL
             &&rNode->left==NULL&&rNode->right==NULL)
                continue;
            else
            {   //注意顺序，先左左后右右，交替入栈
                stk.push(lNode->left);
                stk.push(rNode->right);
                stk.push(lNode->right);
                stk.push(rNode->left);
            }
        }
        return true;
    }
};

方法三：递归

/**
 * 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 subTreeSym(root->left,root->right);
    }

    bool subTreeSym(TreeNode *lNode,TreeNode *rNode)
    {
        if(lNode==NULL&&rNode==NULL)
            return true;
        if(lNode==NULL||rNode==NULL)    //和下面的那个不能颠倒顺序
            return false;
        if(lNode->val !=rNode->val)
            return false;
        
        
        return subTreeSym(lNode->left,rNode->right)&&subTreeSym(lNode->right,rNode->left);
    }


};