LeetCode[Tree]: Populating Next Right Pointers in Each Node

Given a binary tree
struct TreeLinkNode {
TreeLinkNode left;
TreeLinkNode right;
TreeLinkNode next;
}
Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
Initially, all next pointers are set to NULL.
*Note:

• You may only use constant extra space.
• You may assume that it is a perfect binary tree (ie, all leaves are at the same level, and every parent has two children).
  For example,
  Given the following perfect binary tree,
           1
         /  \
        2    3
       / \  / \
      4  5  6  7
  After calling your function, the tree should look like:
  
           1 -> NULL
         /  \
        2 -> 3 -> NULL
       / \  / \
      4->5->6->7 -> NULL

一开始没有注意到O(1)的空间复杂度，于是采用的是跟LeetCode[Tree]: Binary Tree Level Order Traversal类似的方法，得到如下AC的代码：

void connect(TreeLinkNode *root) {
    queue<TreeLinkNode *> levelQ;

    if (root) levelQ.push(root);
    while (!levelQ.empty()) {
        int size = levelQ.size();
        for (int i = 0; i < size; ++i) {
            TreeLinkNode *node = levelQ.front();
            levelQ.pop();

            node->next = (i == size - 1) ? NULL : levelQ.front();

            if (node->left ) levelQ.push(node->left );
            if (node->right) levelQ.push(node->right);
        }
    }
}

后来注意到空间复杂度的限制，在Discuss看到一个非常漂亮的解法。其思路如下：

外层循环控制“层”的迭代，即：每循环一次，完成对树的一层的操作；内层循环控制每一层的所有节点的迭代。这里最关键的问题是内层循环的迭代利用到了上面一层已经完成了next指针的连接，因此可以利用next指针的遍历完成迭代。

根据这个思路，我的C++代码实现非常简洁：

void connect(TreeLinkNode *root) {
    if (!root) return;
    for (TreeLinkNode *pLevelFirstNode = root; pLevelFirstNode->left != nullptr; pLevelFirstNode = pLevelFirstNode->left) {
        for (TreeLinkNode *pCurNode = pLevelFirstNode; pCurNode != nullptr; pCurNode = pCurNode->next) {
            pCurNode->left->next = pCurNode->right;
            if (pCurNode->next) pCurNode->right->next = pCurNode->next->left;
        }
    }
}