leetcode 101 Symmetric Tree



Symmetric Tree Total Accepted: 61440 Total Submissions: 194643 My Submissions

                     

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.

c++ 解决方案：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
#include<queue>
using namespace std;
typedef pair<TreeNode*,TreeNode*> nodepair;
class Solution {
public:
    bool isSymmetricRecursive(TreeNode*a,TreeNode*b){
        if(a){
            return b && a->val==b->val && 
                isSymmetricRecursive(a->left,b->right) &&
                isSymmetricRecursive(a->right,b->left);
        }
        return !b;
    }
    bool isSymmetricRecursive(TreeNode*root){
        return !root || isSymmetricRecursive(root->left,root->right);
    }
    bool isSymmetric(TreeNode *root) {
        // Level-order BFS.
        queue<nodepair> q;
        if(root)
            q.push(make_pair(root->left,root->right));
        while(q.size()){
            nodepair p=q.front(); q.pop();
            if(p.first){
                if(!p.second)return false;
                if(p.first->val != p.second->val) return false;
                // the order of children pushed to q is the key to the solution.
                q.push(make_pair(p.first->left,p.second->right));
                q.push(make_pair(p.first->right,p.second->left));
            }
            else if(p.second) return false;
        }
        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) {
        TreeNode *left, *right;
        if (!root)
            return true;

        queue<TreeNode*> q1, q2;
        q1.push(root->left);
        q2.push(root->right);
        while (!q1.empty() && !q2.empty()){
            left = q1.front();
            q1.pop();
            right = q2.front();
            q2.pop();
            if (NULL == left && NULL == right)
                continue;
            if (NULL == left || NULL == right)
                return false;
            if (left->val != right->val)
                return false;
            q1.push(left->left);
            q1.push(left->right);
            q2.push(right->right);
            q2.push(right->left);
        }
        return true;
    }
};

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if(!root) return true;
        stack<TreeNode*> sk;
        sk.push(root->left);
        sk.push(root->right);

        TreeNode* pA, *pB;
        while(!sk.empty()) {
            pA = sk.top();
            sk.pop();
            pB = sk.top();
            sk.pop();

            if(!pA && !pB) continue;
            if(!pA || !pB) return false;
            if(pA->val != pB->val) return false;

            sk.push(pA->left);
            sk.push(pB->right);
            sk.push(pA->right);
            sk.push(pB->left);
        }

        return true;
    }
};


 

c版本：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool checkNodes(struct TreeNode* a, struct TreeNode* b)
{
    if(a == NULL && b == NULL)
    {
        return true;
    }

    if(a == NULL || b == NULL)
    {
        return false;
    }
    if(a->val != b->val)
    {
        return false;
    }
    return checkNodes(a->left, b->right) && checkNodes(a->right, b->left);
}
bool isSymmetric(struct TreeNode* root) {
    if(root == NULL)
    {
        return true;
    }
    return checkNodes(root->left, root->right);
}

递归方案：

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

    bool helper(TreeNode* p, TreeNode* q) {
        if (!p && !q) {
            return true;
        } else if (!p || !q) {
            return false;
        }

        if (p->val != q->val) {
            return false;
        }

        return helper(p->left,q->right) && helper(p->right, q->left); 
    }

python版本：

class Solution:
    # @param {TreeNode} root
    # @return {boolean}
    def helper(self, a, b):
        if a is None and b is None:
            return True
        if a is None and b is not None:
            return False
        if a is not None and b is None:
            return False
        if a.val != b.val: 
            return False
        return self.helper(a.left, b.right) and self.helper(a.right,b.left)
    def isSymmetric(self, root):
        if root is None:
            return True
        return self.helper(root.left, root.right)

class Solution:
    # @param {TreeNode} root
    # @return {boolean}
    def isSymmetric(self, root):
        # no tree
        # is identical
        if root is None: return True
        if not self.is_identical(root.left, root.right): return False

        queue = []
        # root is identical
        # proceed to queue up the next level
        # (node, depth)

        if root.left:
            enqueue(queue, (root.left, 1))

        if root.right:
            enqueue(queue, (root.right, 1))

        while queue:

            same_level = True
            level = []
            while same_level:
                # still the same level
                if len(queue) > 0 and (len(level) == 0 or level[-1][1] == queue[0][1]):
                    child = dequeue(queue)
                    level.append(child)
                    # enqueue children now to maintain level order
                    # add to the depth
                    if child[0].left:
                        enqueue(queue, (child[0].left, child[1]+1))
                    if child[0].right:
                        enqueue(queue, (child[0].right, child[1]+1))   
                else:
                    same_level = False

            # symmetrical has to be even
            if len(level) % 2 != 0: return False
            while level:
                # grab the two extreme ends 
                (left_node, _), (right_node, _) = level.pop(0), level.pop()
                if not self.is_identical(left_node, right_node): return False


        return True

    def is_identical(self, left, right):
        # if any of them is none, they need to be both none
        if left is None or right is None:
            return left == right

        # their value should equal
        if left.val != right.val:
            return False

        # if left has a left, then right needs to have right
        if left.left:
            if right.right is None:
                return False


        # if left has a right, then right needs to have left
        if left.right:
            if right.left is None:
                return False

        return True




def enqueue(queue, item):
    queue.append(item)

def dequeue(queue):
    return queue.pop(0)