leetcode-100-SameTree

问题

题目：[leetcode-100]

思路

典型的递归判断即可。

代码

/**
 * 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;
    }
};