LC 116.填充每个节点的下一个右侧节点指针

116. 填充每个节点的下一个右侧节点指针

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例 1：

输入： root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释： 给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，‘#’ 标志着每一层的结束。

示例 2:

输入： root = []
输出：[]

提示：

• 树中节点的数量在 $[0,2^{12}-1]$ 范围内
• $-1000\le node.val\le 1000$

进阶：

• 你只能使用常量级额外空间。
• 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

解法一(BFS+队列)

思路分析：

1. 使用二叉树的层序遍历，对二叉树进行层序遍历
2. 在遍历过程中，将每层的节点进行连接
   实现代码如下：

class Solution {
    public Node connect(Node root) {
        if (root == null)
			return null;
		Queue<Node> queue = new ArrayDeque<>();
		queue.offer(root);
		while (!queue.isEmpty()) {
			int size = queue.size();
			for (int i = 0; i < size; ++ i) {
				Node node = queue.poll();
				if (i == size-1) // 此时节点为一层最后的节点
					node.next = null;
				else // 若不为最后一层节点 则指向队列中的下一个即可
					node.next = queue.peek();
				if (node.left != null) queue.offer(node.left);
				if (node.right != null) queue.offer(node.right);
			}
		}
		return root;
    }
return root;
    }
}

提交结果如下：

解答成功:
执行耗时:3 ms,击败了36.17% 的Java用户
内存消耗:43.1 MB,击败了9.05% 的Java用户

复杂度分析：

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

解法二(递归)

思路分析：

1. 对于连接某个节点指向下一个同层右节点，具体重复递归的特点，即左节点指向右节点，因此可以思考使用递归来实现
2. 首先思考递归的参数和返回值，因为具有递归特点即为，左节点指向右节点，因此递归的参数为左边节点和右边界点，同时是连接二叉树结点，因此不需要返回值
3. 然后思考递归的边界条件，即当传递的参数左节点为空或传递的参数右结点为空时，结束递归，此外当左结点的next已指向右节点时，也结束递归，避免重复连接
4. 思考递归的过程，即左参数节点的next指向右参数结点

实现代码如下：

class Solution {
	public Node connect(Node root) {
		if (root != null)
			FConnect(root.left, root.right);
		return root;
	}
	private void FConnect(Node left, Node right) {
		if (left == null || left.next == right || right == null)
			return ;    // 边界
		left.next = right;    // 递归过程 进行连接
		FConnect(left.left, left.right);
		FConnect(left.right, right.left);
		FConnect(right.left, right.right);
	}
}

提交结果如下：

解答成功:
执行耗时:0 ms,击败了100.00% 的Java用户
内存消耗:43.2 MB,击败了5.03% 的Java用户

复杂度分析：

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$，不考虑递归对栈的消耗，则使用常量级空间复杂度