leetcode101. Symmetric Tree

题目描述

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

代码

反转根节点一边的子树，再如100题般判断两颗子树是否相同

#include <iostream>

using namespace std;

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

/// Recursive
/// Revert one child tree and see if the two child trees of the root are identical
///
/// Time Complexity: O(n)
/// Space Complexity: O(h)
class Solution {
public:
    bool isSymmetric(TreeNode* root) {

        if(root == NULL)
            return true;

        TreeNode* left = root->left;
        TreeNode* right = root->right;
        right = revert(right);

        return is_identical(left, right);
    }

private:
    TreeNode* revert(TreeNode* root){
        if(root == NULL)
            return NULL;

        swap(root->left, root->right);
        revert(root->left);
        revert(root->right);
        return root;
    }

    bool is_identical(TreeNode* root1, TreeNode* root2){

        if(root1 == NULL && root2 == NULL)
            return true;

        if(root1 == NULL || root2 == NULL)
            return false;

        if(root1->val != root2->val)
            return false;

        return is_identical(root1->left, root2->left) &&
               is_identical(root1->right, root2->right);
    }
};


int main() {

    return 0;
}

思路二

递归

#include <iostream>

using namespace std;

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

/// Recursive
/// No need to revert one child tree
/// See if the two child trees of the root are mirror directly
///
/// Time Complexity: O(n)
/// Space Complexity: O(h)
class Solution {
public:
    bool isSymmetric(TreeNode* root) {

        if(root == NULL)
            return true;

        return is_mirror(root, root);
    }

private:
    bool is_mirror(TreeNode* root1, TreeNode* root2){

        if(root1 == NULL && root2 == NULL)
            return true;

        if(root1 == NULL || root2 == NULL)
            return false;

        if(root1->val != root2->val)
            return false;

        return is_mirror(root1->left, root2->right) &&
               is_mirror(root1->right, root2->left);
    }
};


int main() {

    return 0;
}

思路三

借助队列

#include <iostream>
#include <queue>

using namespace std;

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

/// Non-Recursive
/// Using two queues to level traverse the root in different directions
///
/// Time Complexity: O(n)
/// Space Complexity: O(n)
class Solution {
public:
    bool isSymmetric(TreeNode* root) {

        if(root == NULL)
            return true;

        queue<TreeNode*> q1, q2;
        q1.push(root);
        q2.push(root);
        while(!q1.empty() && !q2.empty()){
            TreeNode* node1 = q1.front();
            q1.pop();

            TreeNode* node2 = q2.front();
            q2.pop();

            if(node1 == NULL && node2 == NULL)
                continue;

            if(node1 == NULL || node2 == NULL)
                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 q1.empty() && q2.empty();
    }
};


int main() {

    return 0;
}