leetcode第五题 sametree 深度搜索

Given two binary trees, write a function to check if they are the same or not.

Two binary trees are considered the same if they are structurally identical and the nodes have the same value.

Example 1:

Input:     1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

Output: true

Example 2:

Input:     1         1
          /           \
         2             2

        [1,2],     [1,null,2]

Output: false

Example 3:

Input:     1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

Output: false

这个题目利用深度搜索去做，因为只要发现有一个分支不对称，那么就可以判断这两个二叉树不相同

#include <iostream>
using namespace std;
//////链表的节点创建,创建一个节点/////////
struct TreeNode {
       int val;
       TreeNode *lp;
       TreeNode *rp;
       TreeNode();
       TreeNode(int a){val=a;lp=NULL;rp=NULL;};   ////这里创建一个结构体的构造函数，很方便，初始化的时候直接进行初始化
     };

bool isSameTree(TreeNode* p, TreeNode* q) {
    if (p == NULL && q == NULL) return true;  ////当搜索到最底层的时候，返回true
    if (p == NULL || q == NULL) return false;
    if (p->val != q->val) return false;  /////
    return isSameTree(p->lp, q->lp) && isSameTree(p->rp, q->rp); ///这种情况实际上是p和q的val相同的情况，那么就继续比较他们的左右子树，
}

int main() {
    TreeNode *a = new TreeNode(1);
    TreeNode *b = new TreeNode(2);
    TreeNode *c = new TreeNode(3);
    TreeNode *d = new TreeNode(4);
    TreeNode *e = new TreeNode(5);
    TreeNode *f = new TreeNode(6);

    TreeNode *a1 = new TreeNode(1);
    TreeNode *b1 = new TreeNode(2);
    TreeNode *c1= new TreeNode(3);
    TreeNode *d1 = new TreeNode(4);
    TreeNode *e1 = new TreeNode(5);
    TreeNode *f1 = new TreeNode(6);

    a->lp = b;
    a->rp = c;
    b->lp = d;
    b->rp = e;
    c->lp = f;

    a1->lp = b1;
    a1->rp = c1;
    b1->lp = d1;
//    b1->rp = e1;
    c1->lp = f1;
    isSameTree(a,a1);


    return 0;
}

这里我做的二叉树是这样的：

输入两个二叉树:

    1          1
   / \        / \
  2   3      2   3

  /      \      /         /      /

4       5   6       4      6   

通过debug发现，一次搜索的顺序是1,2,4，5 然后就结束了，

说明当 return A&&B的时候，只要确认A是false，那么就没必要再计算B了，但是如果A是true的话，此时无法确认返回值，则需要继续计算B，正是因为语言有这样的功能，才正真实现了，深度搜索。