二叉树的层次遍历

101. 对称二叉树

方法：迭代

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*>q;
        if (root == nullptr) return root;
        q.push(root);

        while (!q.empty()) {
            TreeNode* nod = q.front(); q.pop();
            swap(nod->left, nod->right);
            if (nod->left) q.push(nod->left);
            if (nod->right) q.push(nod->right); 
        }
        return root;
    }
};

$时间复杂度O(n)，空间复杂度O(n)

方法：递归

class Solution {
public:
    TreeNode* invertTree(TreeNode* cur) {
        if (cur == NULL) return cur;
        swap(cur->left, cur->right);
        invertTree(cur->left);
        invertTree(cur->right);
        return cur;
    }
};

$时间复杂度O(n)，空间复杂度O(n)

101. 对称二叉树

方法：迭代

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        queue<TreeNode*>q;
        q.push(root->left);
        q.push(root->right);
        while(!q.empty()) {
            TreeNode* leftNod = q.front(); q.pop();
            TreeNode* rightNod = q.front(); q.pop();
            if(!leftNod && !rightNod) continue;
            if((!leftNod || !rightNod || (leftNod->val != rightNod->val))) return false;
            q.push(leftNod->left);
            q.push(rightNod->right);
            q.push(leftNod->right);
            q.push(rightNod->left);
        }
        return true;
    }
};

$时间复杂度O(n)，空间复杂度O(n)

方法：递归

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

$时间复杂度O(n)，空间复杂度O(n)