一，合并二叉树
617. 合并二叉树 - 力扣（LeetCode）
https://leetcode.cn/problems/merge-two-binary-trees/?plan=algorithms&plan_progress=gzwnnxs
1，深度优先搜索
可以使用深度优先搜索合并两个二叉树。从根节点开始同时遍历两个二叉树，并将对应的节点进行合并。
两个二叉树的对应节点可能存在以下三种情况，对于每种情况使用不同的合并方式。
如果两个二叉树的对应节点都为空，则合并后的二叉树的对应节点也为空；
如果两个二叉树的对应节点只有一个为空，则合并后的二叉树的对应节点为其中的非空节点；
如果两个二叉树的对应节点都不为空，则合并后的二叉树的对应节点的值为两个二叉树的对应节点的值之和，此时需要显性合并两个节点。
对一个节点进行合并之后，还要对该节点的左右子树分别进行合并。这是一个递归的过程。
class Solution { public: TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) { if (t1 == nullptr) { return t2; } if (t2 == nullptr) { return t1; } auto merged = new TreeNode(t1->val + t2->val); merged->left = mergeTrees(t1->left, t2->left); merged->right = mergeTrees(t1->right, t2->right); return merged; } };
复杂度分析
时间复杂度：O(min(m,n))，其中 m 和 n 分别是两个二叉树的节点个数。对两个二叉树同时进行深度优先搜索，只有当两个二叉树中的对应节点都不为空时才会对该节点进行显性合并操作，因此被访问到的节点数不会超过较小的二叉树的节点数。
空间复杂度：O(min(m,n))，其中 m 和 n 分别是两个二叉树的节点个数。空间复杂度取决于递归调用的层数，递归调用的层数不会超过较小的二叉树的最大高度，最坏情况下，二叉树的高度等于节点数。
2，广度优先搜索
也可以使用广度优先搜索合并两个二叉树。首先判断两个二叉树是否为空，如果两个二叉树都为空，则合并后的二叉树也为空，如果只有一个二叉树为空，则合并后的二叉树为另一个非空的二叉树。
如果两个二叉树都不为空，则首先计算合并后的根节点的值，然后从合并后的二叉树与两个原始二叉树的根节点开始广度优先搜索，从根节点开始同时遍历每个二叉树，并将对应的节点进行合并。
使用三个队列分别存储合并后的二叉树的节点以及两个原始二叉树的节点。初始时将每个二叉树的根节点分别加入相应的队列。每次从每个队列中取出一个节点，判断两个原始二叉树的节点的左右子节点是否为空。如果两个原始二叉树的当前节点中至少有一个节点的左子节点不为空，则合并后的二叉树的对应节点的左子节点也不为空。对于右子节点同理。
如果合并后的二叉树的左子节点不为空，则需要根据两个原始二叉树的左子节点计算合并后的二叉树的左子节点以及整个左子树。考虑以下两种情况：
如果两个原始二叉树的左子节点都不为空，则合并后的二叉树的左子节点的值为两个原始二叉树的左子节点的值之和，在创建合并后的二叉树的左子节点之后，将每个二叉树中的左子节点都加入相应的队列；
如果两个原始二叉树的左子节点有一个为空，即有一个原始二叉树的左子树为空，则合并后的二叉树的左子树即为另一个原始二叉树的左子树，此时也不需要对非空左子树继续遍历，因此不需要将左子节点加入队列。
对于右子节点和右子树，处理方法与左子节点和左子树相同。
class Solution { public: TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) { if (t1 == nullptr) { return t2; } if (t2 == nullptr) { return t1; } auto merged = new TreeNode(t1->val + t2->val); auto q = queue<TreeNode*>(); auto queue1 = queue<TreeNode*>(); auto queue2 = queue<TreeNode*>(); q.push(merged); queue1.push(t1); queue2.push(t2); while (!queue1.empty() && !queue2.empty()) { auto node = q.front(), node1 = queue1.front(), node2 = queue2.front(); q.pop(); queue1.pop(); queue2.pop(); auto left1 = node1->left, left2 = node2->left, right1 = node1->right, right2 = node2->right; if (left1 != nullptr || left2 != nullptr) { if (left1 != nullptr && left2 != nullptr) { auto left = new TreeNode(left1->val + left2->val); node->left = left; q.push(left); queue1.push(left1); queue2.push(left2); } else if (left1 != nullptr) { node->left = left1; } else if (left2 != nullptr) { node->left = left2; } } if (right1 != nullptr || right2 != nullptr) { if (right1 != nullptr && right2 != nullptr) { auto right = new TreeNode(right1->val + right2->val); node->right = right; q.push(right); queue1.push(right1); queue2.push(right2); } else if (right1 != nullptr) { node->right = right1; } else { node->right = right2; } } } return merged; } };
复杂度分析
时间复杂度：O(min(m,n))，其中 m 和 n 分别是两个二叉树的节点个数。对两个二叉树同时进行广度优先搜索，只有当两个二叉树中的对应节点都不为空时才会访问到该节点，因此被访问到的节点数不会超过较小的二叉树的节点数。
空间复杂度：O(min(m,n))，其中 m 和 n 分别是两个二叉树的节点个数。空间复杂度取决于队列中的元素个数，队列中的元素个数不会超过较小的二叉树的节点数。
二，填充每个结点的下一个右侧节点指针
116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）
1，层次遍历：
题目本身希望我们将二叉树的每一层节点都连接起来形成一个链表。因此直观的做法我们可以对二叉树进行层次遍历，在层次遍历的过程中将我们将二叉树每一层的节点拿出来遍历并连接。
层次遍历基于广度优先搜索，它与广度优先搜索的不同之处在于，广度优先搜索每次只会取出一个节点来拓展，而层次遍历会每次将队列中的所有元素都拿出来拓展，这样能保证每次从队列中拿出来遍历的元素都是属于同一层的，因此我们可以在遍历的过程中修改每个节点的next 指针，同时拓展下一层的新队列。
class Solution { public: Node* connect(Node* root) { if (root == nullptr) { return root; } // 初始化队列同时将第一层节点加入队列中，即根节点 queue<Node*> Q; Q.push(root); // 外层的 while 循环迭代的是层数 while (!Q.empty()) { // 记录当前队列大小 int size = Q.size(); // 遍历这一层的所有节点 for(int i = 0; i < size; i++) { // 从队首取出元素 Node* node = Q.front(); Q.pop(); // 连接 if (i < size - 1) { node->next = Q.front(); } // 拓展下一层节点 if (node->left != nullptr) { Q.push(node->left); } if (node->right != nullptr) { Q.push(node->right); } } } // 返回根节点 return root; } };
复杂度分析
时间复杂度：O(N)。每个节点会被访问一次且只会被访问一次，即从队列中弹出，并建立 next 指针。
空间复杂度：O(N)。这是一棵完美二叉树，它的最后一个层级包含N/2 个节点。广度优先遍历的复杂度取决于一个层级上的最大元素数量。这种情况下空间复杂度为 O(N)。
2，使用已建立的 next 指针
思路
1）一棵树中，存在两种类型的next 指针。
第一种情况是连接同一个父节点的两个子节点。它们可以通过同一个节点直接访问到，因此执行下面操作即可完成连接。
node.left.next = node.right
2）第二种情况在不同父亲的子节点之间建立连接，这种情况不能直接连接。
如果每个节点有指向父节点的指针，可以通过该指针找到 next 节点。如果不存在该指针，则按照下面思路建立连接：
第 N 层节点之间建立 next 指针后，再建立第 N+1 层节点的 next 指针。可以通过 next 指针访问同一层的所有节点，因此可以使用第 N 层的 next 指针，为第 N+1 层节点建立 next 指针。
算法
1）从根节点开始，由于第 0 层只有一个节点，所以不需要连接，直接为第 1 层节点建立 next 指针即可。该算法中需要注意的一点是，当我们为第 N 层节点建立 next 指针时，处于第 N−1 层。当第 N 层节点的 next 指针全部建立完成后，移至第 N 层，建立第 N+1 层节点的 next 指针。
2）遍历某一层的节点时，这层节点的next 指针已经建立。因此我们只需要知道这一层的最左节点，就可以按照链表方式遍历，不需要使用队列。
3）上面思路的伪代码如下：
leftmost = root while (leftmost.left != null) { head = leftmost while (head.next != null) { 1) Establish Connection 1 2) Establish Connection 2 using next pointers head = head.next } leftmost = leftmost.left }
4）两种类型的next 指针。
1，第一种情况两个子节点属于同一个父节点，因此直接通过父节点建立两个子节点的 next 指针即可。
node.left.next = node.right
2，第二种情况是连接不同父节点之间子节点的情况。更具体地说，连接的是第一个父节点的右孩子和第二父节点的左孩子。由于已经在父节点这一层建立了 next 指针，因此可以直接通过第一个父节点的 next 指针找到第二个父节点，然后在它们的孩子之间建立连接。
node.right.next = node.next.left
5）完成当前层的连接后，进入下一层重复操作，直到所有的节点全部连接。进入下一层后需要更新最左节点，然后从新的最左节点开始遍历该层所有节点。因为是完美二叉树，因此最左节点一定是当前层最左节点的左孩子。如果当前最左节点的左孩子不存在，说明已经到达该树的最后一层，完成了所有节点的连接。
class Solution { public: Node* connect(Node* root) { if (root == nullptr) { return root; } // 从根节点开始 Node* leftmost = root; while (leftmost->left != nullptr) { // 遍历这一层节点组织成的链表，为下一层的节点更新 next 指针 Node* head = leftmost; while (head != nullptr) { // CONNECTION 1 head->left->next = head->right; // CONNECTION 2 if (head->next != nullptr) { head->right->next = head->next->left; } // 指针向后移动 head = head->next; } // 去下一层的最左的节点 leftmost = leftmost->left; } return root; } };
复杂度分析
- 时间复杂度：O(N)，每个节点只访问一次。
- 空间复杂度：O(1)，不需要存储额外的节点。
