算法思想:
首先我们引入一个队列,这是把递归程序改写成迭代程序的常用方法。初始化时我们把根节点入队两次。每次提取两个结点并比较它们的值(队列中每两个连续的结点应该是相等的,而且它们的子树互为镜像),然后将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时,或者我们检测到树不对称(即从队列中取出两个不相等的连续结点)时,该算法结束。
/**
* 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* root1, TreeNode* root2){
queue<TreeNode*> q;
q.push(root1);
q.push(root2);
while(q.empty() == 0){
TreeNode* a = q.front();
q.pop();
TreeNode* b = q.front();
q.pop();
if(a == nullptr && b == nullptr) continue;
if((!a || !b) || (a->val != b->val)) return false;
q.push(a->left);
q.push(b->right);
q.push(a->right);
q.push(b->left);
}
return true;
}
bool isSymmetric(TreeNode* root) {
return check(root, root);
}
};
复杂度分析:
- 时间复杂度:O(n)。
- 空间复杂度:这里需要用一个队列来维护节点,每个节点最多进队一次,出队一次,队列中最多不会超过 n 个点,故渐进空间复杂度为 O(n)。
python
非递归
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#
#
# @param root TreeNode类
# @return bool布尔型
#
class Solution:
def isSymmetric(self , root):
# write code here
if not root:
return True
q = [root, root]
while q:
node1 = q.pop(0)
node2 = q.pop(0)
if node1 == None and node2 == None:
continue
if node1 == None or node2 == None or node1.val != node2.val:
return False
q.append(node1.left)
q.append(node2.right)
q.append(node1.right)
q.append(node2.left)
return True
递归
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
#
#
# @param root TreeNode类
# @return bool布尔型
#
class Solution:
def isSymmetric(self , root):
# write code here
def dfs(p, q):
if not p and not q:
return True
if not p or not q:
return False
return p.val == q.val and dfs(p.left, q.right) and dfs(p.right, q.left)
return dfs(root, root)