easy 相同的树 深度优先搜索（递归） 广度优先搜索 （队列）

---

树的算法

DFS 深度优先搜索（递归）：

c++

/*  Depth-First-Search  */
/**
 * 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 isSameTree(TreeNode* p, TreeNode* q) {
        if ( p==nullptr && q == nullptr ){
            return true;
        }else if(p==nullptr || q == nullptr ){
            return false;
        }else if(p->val !=  q->val){
            return false;
        }else{
            return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
        }
    }
};

python

python 在 def function1 中调用 function1: self.function1

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if not p and not q:
            return True
        elif not p or not q:
            return False
        elif p.val != q.val:
            return False
        else:
            return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
            # python 在def function1 中调用 function1: self.function1

---

BFS 广度优先搜索 （队列）：

c++

STL中队列（queue）的使用方法

#include <queue>
queue <TreeNode*> queue1;  // 存放指针的队列
queue <int> queue2;   // 存放整数的队列

push(x) 将x压入队列的末端

pop() 弹出队列的第一个元素(队顶元素)，注意此函数并不返回任何值

front() 返回第一个元素(队顶元素)

back() 返回最后被压入的元素(队尾元素)

empty() 当队列为空时，返回true

size() 返回队列的长度

add() 往队列尾部插入元素，当超出队列界限的时候，抛出异常让你处理，

offer() 往队列尾部插入元素，当超出队列界限的时候，直接返回false

size() 访问队列中的元素个数

两个队列

/*Breadth-First-Search* 两个队列 /
/**
 * 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 isSameTree(TreeNode* p, TreeNode* q) {
        if ( p == nullptr && q == nullptr ){
            return true;
        }else if( p == nullptr || q == nullptr ){
            return false;
        }

        queue <TreeNode*> queue1,queue2;  // 创建队列
        queue1.push(p);   // 指针 p 进队 
        queue2.push(q);   // 指针 q 进队

        while( !queue1.empty() && !queue2.empty() ){
            auto node1 = queue1.front();  // 获取队顶元素，auto自动指定类型
            auto node2 = queue2.front(); 
            queue1.pop();   // 弹出队顶元素
            queue2.pop();

            if (node1->val != node2->val) {
                return false;
            }

            auto left1 = node1->left, right1 = node1->right;
            auto left2 = node2->left, right2 = node2->right;
            // 两个if都需要判断，所用不用else连起来
            if((left1 == nullptr) ^ (left2 == nullptr)){  // 异或，一个为空一个不为空，条件成立
                return false;
            }
            if((right1 == nullptr) ^ (right2 == nullptr)){  
                return false;
            }
            if(left1 != nullptr){
                queue1.push(left1);  // 子节点加入队列时需要注意顺序，先加入左子节点，后加入右子节点
            }
            if(right1 != nullptr){
                queue1.push(right1);
            }
            if(left2 != nullptr){
                queue2.push(left2);
            }
            if(right2 != nullptr){
                queue2.push(right2);
            }

        }

        return queue1.empty() && queue2.empty();
    }
};

一个队列

/*Breadth-First-Search* 一个队列 /
/**
 * 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 isSameTree(TreeNode* p, TreeNode* q) {
        if ( p == nullptr && q == nullptr ){
            return true;
        }else if( p == nullptr || q == nullptr ){
            return false;
        }

        queue <TreeNode*> queue1; // 创建队列
        queue1.push(p);   // 指针 p 进队 
        queue1.push(q);   // 指针 q 进队

        while( !queue1.empty() ){
            auto node1 = queue1.front();  // 获取队顶元素，auto自动指定类型
            queue1.pop();   // 弹出队顶元素
            auto node2 = queue1.front(); 
            queue1.pop();

            if (node1->val != node2->val) {
                return false;
            }

            auto left1 = node1->left, right1 = node1->right;
            auto left2 = node2->left, right2 = node2->right;
            // 两个if都需要判断，所用不用else连起来
            if((left1 == nullptr) ^ (left2 == nullptr)){  // 异或，一个为空一个不为空，条件成立
                return false;
            }
            if((right1 == nullptr) ^ (right2 == nullptr)){  
                return false;
            }
            if(left1 != nullptr){
                queue1.push(left1);  // 子节点加入队列时需要注意顺序，先加入p左子节点，后加入q左子节点
            }
            if(left2 != nullptr){
                queue1.push(left2);
            }
            if(right1 != nullptr){
                queue1.push(right1);
            }
            if(right2 != nullptr){
                queue1.push(right2);
            }

        }

        return queue1.empty();
    }
};

python

deque是双边队列，具有队列和栈的性质。相当于可以在两端操作的list

import collections

d = collections.deque([])
d.append('a') # 在最右边添加一个元素
d.appendleft('b') # 在最左边添加一个元素
d.extend(['c','d']) # 在最右边添加所有元素
d.extendleft(['e','f']) # 在最左边添加所有元素
d.pop() # 将最右边的元素取出
d.popleft() # 将最左边的元素取出
d.rotate(-2) # 向左旋转两个位置（正数则向右旋转）
d.count('a') # 队列中'a'的个数
d.remove('c') # 从队列中将'c'删除
d.reverse() # 将队列倒序
f=d.copy()  # 复制队列
f.clear()  # 清空队列

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if not p and not q:
            return True
        if not p or not q:
            return False

        queue1 = collections.deque([p])   # 创建python双端队列，并放入p
        queue2 = collections.deque([q])

        while queue1 and queue2:
            node1 = queue1.popleft()  # 返回并删除队列顶端元素
            node2 = queue2.popleft()
            if node1.val != node2.val:
                return False

            left1,right1 = node1.left, node1.right
            left2,right2 = node2.left, node2.right

            if (not left1) ^ (not left2):  # 左节点
                return False
            if (not right1) ^ (not right2):   # 右节点
                return False


            if left1:
                queue1.append(left1)  # 从队尾进队
            if right1:
                queue1.append(right1)
            if left2:
                queue2.append(left2)
            if right2:
                queue2.append(right2)


        return not queue1 and not queue2

---