leetcode 116. Populating Next Right Pointers in Each Node-递归|非递归

原题链接：116. Populating Next Right Pointers in Each Node
【思路-Java、Python】

由于题目要求不能申请额外空间，并且已经说明给定的树为完全二叉树。

public class Solution {
public void connect(TreeLinkNode root) {
if (root == null) return;
TreeLinkNode nextLevelFirst = null;
while (root.left != null) {  //当前节点的左子树为空的完全二叉树意味着下一层没有节点
nextLevelFirst = root.left;
while (root != null) {
root.left.next = root.right;  //连接父节点的左右孩子
root.right.next = root.next==null ? null : root.next.left;  //连接堂兄弟的左右节点
root = root.next;
}
root = nextLevelFirst;
}
}
}

14 / 14 test
cases passed. Runtime: 0 ms  Your runtime beats 81.40% of javasubmissions.

class Solution(object):
def connect(self, root):
"""
:type root: TreeLinkNode
:rtype: nothing
"""
if not root : return
nextLevelFirst = root
while root.left :
nextLevelFirst = root.left
while root :
root.left.next = root.right
if root.next != None: root.right.next = root.next.left
root = root.next
root = nextLevelFirst

14 / 14 test
cases passed. Runtime: 101 ms  Your runtime beats 35.38% of pythonsubmissions.

【思路2-Java、Python】-递归实现

递归实现空间复杂度肯定是不符合要求的，但是，为了扩展视野，既懂递归实现又懂非递归实现，可以很好地帮助我们理解两者的区别，实际编程中可以游刃有余：

1. 既然非递归寻找下一层的第一个节点需要用到 nextLevelFirst，那么我们同样地在形参中增加一个 nextLevelFirst 参数。

2. 非递归实现的终止条件是 nextLevelFirst 为空，那么递归实现的终止条件也是 nextLevelFirst 为空

3. 非递归的 next 节点为空时，进行下一层的遍历，那么递归实现进行下一层遍历的条件也是 root.next 为空。同时更新 nextLeftFirst 引用

从上面几点，我们可以看到递归和非递归是高度统一的：

public class Solution {
public void connect(TreeLinkNode root) {
if (root != null)
dfs(root, root.left);
}
private void dfs(TreeLinkNode root, TreeLinkNode nextLevelFirst) {
if (nextLevelFirst == null) return;
root.left.next = root.right;
if (root.next == null) {
dfs(nextLevelFirst, nextLevelFirst.left);
} else {
root.right.next = root.next.left;
dfs(root.next, nextLevelFirst);
}
}
}

14 / 14 test
cases passed. Runtime: 1 ms  Your runtime beats 29.25% of javasubmissions.

class Solution(object):
def connect(self, root):
if not (root and root.left):
return

root.left.next = root.right
if root.next:
root.right.next = root.next.left

map(self.connect, (root.left, root.right))

14 / 14 test
cases passed. Runtime: 104 ms  Your runtime beats 23.10% of pythonsubmissions.

【思路3-Java】-仅供参考，不推荐

如果没有仔细思考，没有利用到 next 指针，我们可能很快就想到利用队列实现二叉树的层次遍历，但这样与思路1相比不仅造成空间浪费，而且时间复杂度更高：

public class Solution {
public void connect(TreeLinkNode root) {
if (root == null) return;
Queue<TreeLinkNode> queue = new LinkedList<TreeLinkNode>();
queue.add(root);
queue.add(null);     //将null加入该层的结尾，作为该层的结束标志
TreeLinkNode temp = root;
while (!queue.isEmpty()) {
if (root != null) {         //本层还未遍历完
if (root.left != null)  //将左孩子加入队列，作为下一层节点
queue.add(root.left);
if (root.right != null)  //将右孩子加入队列，作为下一层节点
queue.add(root.right);
} else {                   //本层遍历完成，开始遍历下一层
queue.add(null);       //加入null作为本层结束的标志
root = queue.poll();
temp = root;
continue;
}
root = queue.poll();      //取出本层的下一个节点
temp.next = root;         //设置next指针
temp = root;
}
}
}

14 / 14 test
cases passed. Runtime: 8 ms  Your runtime beats 2.81% of javasubmissions.