【二叉树】LC 101.对称二叉树

文章目录

前言
一、题目
- 1、原题链接
- 2、题目描述
二、个人思路整理
- 1、思路分析
- - [递归解法（时间复杂度O(n) 、空间复杂度O(h)）](#递归解法（时间复杂度O(n) 、空间复杂度O(h)）)
  - 迭代解法（空间复杂度O(n)、时间复杂度O(w)）
- 2、解题代码
- - [递归解法（时间复杂度O(n) 、空间复杂度O(h)）](#递归解法（时间复杂度O(n) 、空间复杂度O(h)）)
  - 迭代解法（空间复杂度O(n)、时间复杂度O(w)）
三、知识风暴

前言

本专栏文章为《LeetCode 热题 100》的刷题题解，相关内容如有侵权，立即删除。

一、题目

1、原题链接

101.对称二叉树

2、题目描述

二、个人思路整理

1、思路分析

递归解法（时间复杂度O(n) 、空间复杂度O(h)）

判断两棵树是否互为镜像对称：

判断根节点是否相等；
判断外侧节点（左子树的左节点与右子树的右节点）和内侧节点（左子树的右节点与右子树的左节点）是否相等。

复杂度分析

时间复杂度： O ( n ) \mathcal{O}(n) O(n)，其中 n n n 为节点总数，每个节点最多被遍历一次。

空间复杂度： O ( h ) \mathcal{O}(h) O(h)，其中 h h h 为树的高度，递归栈深度取决于树高。

迭代解法（空间复杂度O(n)、时间复杂度O(w)）

也可以利用队列，将递归写法改写为迭代写法。

复杂度分析

时间复杂度： O ( n ) O(n) O(n)，遍历所有节点。

空间复杂度： O ( w ) O(w) O(w)，队列中最多保存树中节点较多那一层的节点数（即树的最大宽度 w w w）。

2、解题代码

递归解法（时间复杂度O(n) 、空间复杂度O(h)）

cpp 复制代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // 判断是否镜像对称
    bool check(TreeNode* l, TreeNode* r) {
        // 两节点均为空，对称
        if (l == nullptr && r == nullptr) {
            return true;
        }
        // 只有一个节点为空，不对称
        if (l == nullptr || r == nullptr) {
            return false;
        }
        // 都不为空，但值不同，不对称
        if (l->val != r->val) {
            return false;
        }
        // 如果两节点均非空且值相同，则递归判断其左、右子树
        // 镜像条件，需同时满足外侧与内侧条件：
        // 1.外侧：左子树的左节点与右子树的右节点相同
        // 2.内侧：左子树右节点与右子树的左节点相同
        return check(l->left, r->right) && check(l->right, r->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root == nullptr) {
            return true;
        }
        return check(root->left, root->right);
    }
};

迭代解法（空间复杂度O(n)、时间复杂度O(w)）

cpp 复制代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == nullptr) {
            return true;
        }
        queue<TreeNode*> q;
        q.push(root->left);
        q.push(root->right);
        while(!q.empty()) {
            TreeNode* l = q.front();
            q.pop();
            TreeNode* r = q.front();
            q.pop();
            // 递归方法类似判断条件
            if (l == nullptr && r == nullptr) {
                continue;
            }
            if (l == nullptr || r == nullptr) {
                return false;
            }
            if (l->val != r->val) {
                return false;
            }
            //处理外侧
            q.push(l->left);
            q.push(r->right);
            //处理内侧
            q.push(l->right);
            q.push(r->left);
        }
        return true;
    }
};

三、知识风暴

DFS和BFS