leetcode 101. Symmetric Tree

leetcode 101. Symmetric Tree

(Easy)

Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).

For example, this binary tree [1,2,2,3,4,4,3] is symmetric:

    1
   / \
  2   2
 / \ / \
3  4 4  3	

But the following [1,2,2,null,3,null,3] is not:

    1
   / \
  2   2
   \   \
   3    3

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

树的结构:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

• 核心问题: 检查二叉树是否对称

  Notes: 可以分别思考使用递归、迭代的解法.

递归:

• 一个树对称,等价于两个子树对称后分别是对方

代码:

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)
            return true;
        return isSymmetric(root->left,root->right);
        
    }
    
    bool isSymmetric(TreeNode* l, TreeNode* r)
    {
        if(l == NULL && r == NULL)
            return true;
        if(l != NULL && r != NULL && l->val == r->val)
            return isSymmetric(l->left,r->right) && isSymmetric(l->right, r->left);
        return false;
    }
};

时间复杂度应该是O(n),每个点只对比且至多只对比一次

另一种思路: 考虑二叉树的中序遍历, 如果一个树对称,那么中序遍历得到的序列应该是对称的?

思考后发现不对…

反例:

    1
   / \
  3   2
   \   \
   2    3

中序遍历序列为 3-2-1-2-3, 但二叉树本身不对称.

中序遍历序列对称是二叉树对称的必要不充分条件

用栈实现:

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)
            return true;
        TreeNode *l;
        TreeNode *r;
        stack<TreeNode*> Tstack;
        Tstack.push(root->left);
        Tstack.push(root->right);
        while(!Tstack.empty())
        {
            l = Tstack.top();
            Tstack.pop();
            r = Tstack.top();
            Tstack.pop();
            if(l == NULL && r == NULL)
                continue;
            else if(l != NULL && r != NULL && l->val == r->val)
            {
                Tstack.push(l->left);
                Tstack.push(r->right);
                Tstack.push(l->right);
                Tstack.push(r->left);
            }
            else
                return false;

        }
        return true;
        
    }
    
    
};

运行出来的效率和用函数递归差不多.