问题
思路
典型的递归判断即可。
代码
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
if( !p && !q ) return true;
else if(p && !q) return false;
else if( !p && q ) return false;
else{
return p->val == q->val && isSameTree(p->left, q->left) && isSameTree( p->right, q->right );
}
}
代码1
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q) return true;
if(p&&!q || !p&&q || p->val != q->val ) return false;
bool ret = isSameTree(p->left, q->left);
if(!ret) return false;
return isSameTree(p->right, q->right);
}
};
思路2
其实这种非递归的写法,也是种遍历策略。
只不过不是按照之前的标准的深度优先或者广度优先。
这种遍历本质上是基于广度优先,但是它无法得到和正规的bfs一样的元素需要。因为它入队的元素不是按着顺序入队的,而是跳跃着进行入队的。
这么做,主要是用来判断两颗子树上“对称”或者“镜像”元素是否相等的遍历方法。
思路基本是bfs,但是同一层不是标准的顺序。而是跳跃着的。
注意这个题和symmetric tree,算法框架一模一样。注意,p和q同时为空的情形,此时只能continue.因为还有没有判断完的“对称”或者“镜像”元素。
代码2
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
stack<TreeNode*> stk;
stk.push(p);
stk.push(q);
while(!stk.empty()){
q = stk.top(); stk.pop();
p = stk.top(); stk.pop();
if(!p && !q) continue;
if(p&&!q || !p&&q || p->val != q->val) return false;
stk.push(p->left);
stk.push(q->left);
stk.push(p->right);
stk.push(q->right);
}
return true;
}
};